![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to platform.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / boot / windows|
Return to platform.cpp CVS log | Up to [truecrypt] / truecrypt / boot / windows |
1.1 root 1: /*
2: Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
3:
4: Governed by the TrueCrypt License 2.4 the full text of which is contained
5: in the file License.txt included in TrueCrypt binary and source code
6: distribution packages.
7: */
8:
9: #include "Platform.h"
10:
11:
12: uint64 operator+ (const uint64 &a, const uint64 &b)
13: {
14: int carry = 0;
15: uint64 r;
16:
17: r.LowPart = a.LowPart + b.LowPart;
18: __asm
19: {
20: jnc nocarry
21: mov carry, 1
22: nocarry:
23: }
24:
25: r.HighPart = a.HighPart + b.HighPart + carry;
26:
27: return r;
28: }
29:
30: uint64 operator+ (const uint64 &a, uint32 b)
31: {
32: uint64 b64;
33: b64.HighPart = 0;
34: b64.LowPart = b;
35: return a + b64;
36: }
37:
38: uint64 operator- (const uint64 &a, const uint64 &b)
39: {
40: int carry = 0;
41: uint64 r;
42:
43: r.LowPart = a.LowPart - b.LowPart;
44: __asm
45: {
46: jnc nocarry
47: mov carry, 1
48: nocarry:
49: }
50:
51: r.HighPart = a.HighPart - b.HighPart - carry;
52:
53: return r;
54: }
55:
56: uint64 operator- (const uint64 &a, uint32 b)
57: {
58: uint64 b64;
59: b64.HighPart = 0;
60: b64.LowPart = b;
61: return a - b64;
62: }
63:
64: uint64 operator>> (const uint64 &a, int shiftCount)
65: {
66: uint64 r = a;
67:
68: while (shiftCount--)
69: {
70: r.LowPart >>= 1;
71:
72: if ((byte) r.HighPart & 1)
73: r.LowPart |= 0x80000000UL;
74:
75: r.HighPart >>= 1;
76: }
77:
78: return r;
79: }
80:
81: uint64 operator<< (const uint64 &a, int shiftCount)
82: {
83: uint64 r = a;
84:
85: while (shiftCount--)
86: r = r + r;
87:
88: return r;
89: }
90:
91: uint64 &operator++ (uint64 &a)
92: {
93: return a = a + 1;
94: }
95:
96: bool operator== (const uint64 &a, const uint64 &b)
97: {
98: return a.HighPart == b.HighPart && a.LowPart == b.LowPart;
99: }
100:
101: bool operator> (const uint64 &a, const uint64 &b)
102: {
103: return (a.HighPart > b.HighPart) || (a.HighPart == b.HighPart && a.LowPart > b.LowPart);
104: }
105:
106: bool operator< (const uint64 &a, const uint64 &b)
107: {
108: return (a.HighPart < b.HighPart) || (a.HighPart == b.HighPart && a.LowPart < b.LowPart);
109: }
110:
111: bool operator>= (const uint64 &a, const uint64 &b)
112: {
113: return a > b || a == b;
114: }
115:
116: bool operator<= (const uint64 &a, const uint64 &b)
117: {
118: return a < b || a == b;
119: }
120:
121: bool TestInt64 ()
122: {
123: uint64 a, b, c;
124: a.HighPart = 0x00112233UL;
125: a.LowPart = 0xabcd1234UL;
126:
127: b.HighPart = 0x00ffeeddUL;
128: b.LowPart = 0xffffFFFFUL;
129:
130: ++a;
131: b = b + (uint32) 1UL;
132:
133: c = (a - ((a + b) >> 32) - (uint32) 1UL);
134: if (c.HighPart != 0x112233UL || c.LowPart != 0xAABC0123UL)
135: return false;
136:
137: c = c << 9;
138: return c.HighPart == 0x22446755UL && c.LowPart == 0x78024600UL;
139: }
140:
141:
142: void CopyMemory (byte *source, uint16 destSegment, uint16 destOffset, uint16 blockSize)
143: {
144: __asm
145: {
146: push es
147: mov si, ss:source
148: mov es, ss:destSegment
149: mov di, ss:destOffset
150: mov cx, ss:blockSize
151: cld
152: rep movsb
153: pop es
154: }
155: }
156:
157:
158: void CopyMemory (uint16 sourceSegment, uint16 sourceOffset, byte *destination, uint16 blockSize)
159: {
160: __asm
161: {
162: push ds
163: push es
164: mov ax, ds
165: mov es, ax
166: mov di, ss:destination
167: mov si, ss:sourceOffset
168: mov cx, ss:blockSize
169: mov ds, ss:sourceSegment
170: cld
171: rep movsb
172: pop es
173: pop ds
174: }
175: }
176:
177:
1.1.1.3 ! root 178: void EraseMemory (void *memory, int size)
! 179: {
! 180: byte *m = (byte *) memory;
! 181:
! 182: while (size--)
! 183: {
! 184: *m++ = 0;
! 185: }
! 186: }
! 187:
! 188:
1.1 root 189: uint32 GetLinearAddress (uint16 segment, uint16 offset)
190: {
191: return (uint32 (segment) << 4) + offset;
192: }
1.1.1.2 root 193:
194:
195: bool RegionsIntersect (const uint64 &start1, uint32 length1, const uint64 &start2, const uint64 &end2)
196: {
197: uint64 end1 = start1 + length1 - 1UL;
198: uint64 intersectEnd = (end1 <= end2) ? end1 : end2;
199:
200: uint64 intersectStart = (start1 >= start2) ? start1 : start2;
201: if (intersectStart > intersectEnd)
202: return false;
203:
204: return (intersectEnd + 1UL - intersectStart).LowPart != 0;
205: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.