1:
2: // Compiler implementation of the D programming language
3: // Copyright (c) 1999-2011 by Digital Mars
4: // All Rights Reserved
5: // written by KennyTM
6: // http://www.digitalmars.com
7: // License for redistribution is by either the Artistic License
8: // in artistic.txt, or the GNU General Public License in gnu.txt.
9: // See the included readme.txt for details.
10:
11: #include "intrange.h"
12: #include "mars.h"
13: #include "mtype.h"
14: #include "expression.h"
15:
16: #ifndef PERFORM_UNITTEST
17: #define PERFORM_UNITTEST 0
18: #endif
19:
20: // Copy the sign to the value *x*. Equivalent to `sign ? -x : x`.
21: static uinteger_t copySign(uinteger_t x, bool sign)
22: {
23: // return sign ? -x : x;
24: return (x - sign) ^ -sign;
warning C4804: '-' : unsafe use of type 'bool' in operation
warning C6323: Use of arithmetic operator on Boolean type(s)
warning C6323: Use of arithmetic operator on Boolean type(s)
25: }
26:
27: #ifndef UINT64_MAX
28: #define UINT64_MAX 0xFFFFFFFFFFFFFFFFULL
29: #endif
30:
31: //==================== SignExtendedNumber ======================================
32:
33: SignExtendedNumber SignExtendedNumber::fromInteger(uinteger_t value_)
34: {
35: return SignExtendedNumber(value_, value_ >> 63);
warning C4800: 'uinteger_t' : forcing value to bool 'true' or 'false' (performance warning)
36: }
37:
38: bool SignExtendedNumber::operator==(const SignExtendedNumber& a) const
39: {
40: return value == a.value && negative == a.negative;
41: }
42:
43: bool SignExtendedNumber::operator<(const SignExtendedNumber& a) const
44: {
45: return (negative && !a.negative)
46: || (negative == a.negative && value < a.value);
47: }
48:
49: SignExtendedNumber SignExtendedNumber::extreme(bool minimum)
50: {
51: return SignExtendedNumber(minimum-1, minimum);
warning C6323: Use of arithmetic operator on Boolean type(s)
52: }
53:
54: SignExtendedNumber SignExtendedNumber::max()
55: {
56: return SignExtendedNumber(UINT64_MAX, false);
57: }
58:
59: SignExtendedNumber SignExtendedNumber::operator-() const
60: {
61: if (value == 0)
62: return SignExtendedNumber(-negative);
warning C4804: '-' : unsafe use of type 'bool' in operation
63: else
64: return SignExtendedNumber(-value, !negative);
warning C4146: unary minus operator applied to unsigned type, result still unsigned
65: }
66:
67: SignExtendedNumber SignExtendedNumber::operator+(const SignExtendedNumber& a) const
68: {
69: uinteger_t sum = value + a.value;
70: bool carry = sum < value && sum < a.value;
71: if (negative != a.negative)
72: return SignExtendedNumber(sum, !carry);
73: else if (negative)
74: return SignExtendedNumber(carry ? sum : 0, true);
75: else
76: return SignExtendedNumber(carry ? UINT64_MAX : sum, false);
77: }
78:
79: SignExtendedNumber SignExtendedNumber::operator-(const SignExtendedNumber& a) const
80: {
81: if (a.isMinimum())
82: return negative ? SignExtendedNumber(value, false) : max();
83: else
84: return *this + (-a);
85: }
86:
87:
88: SignExtendedNumber SignExtendedNumber::operator*(const SignExtendedNumber& a) const
89: {
90: // perform *saturated* multiplication, otherwise we may get bogus ranges
91: // like 0x10 * 0x10 == 0x100 == 0.
92:
93: /* Special handling for zeros:
94: INT65_MIN * 0 = 0
95: INT65_MIN * + = INT65_MIN
96: INT65_MIN * - = INT65_MAX
97: 0 * anything = 0
98: */
99: if (value == 0)
100: {
101: if (!negative)
102: return *this;
103: else if (a.negative)
104: return max();
105: else
106: return a.value == 0 ? a : *this;
107: }
108: else if (a.value == 0)
109: return a * *this; // don't duplicate the symmetric case.
110:
111: SignExtendedNumber rv;
112: // these are != 0 now surely.
113: uinteger_t tAbs = copySign(value, negative);
114: uinteger_t aAbs = copySign(a.value, a.negative);
115: rv.negative = negative != a.negative;
116: if (UINT64_MAX / tAbs < aAbs)
117: rv.value = rv.negative-1;
118: else
119: rv.value = copySign(tAbs * aAbs, rv.negative);
120: return rv;
121: }
122:
123: SignExtendedNumber SignExtendedNumber::operator/(const SignExtendedNumber& a) const
124: {
125: /* special handling for zeros:
126: INT65_MIN / INT65_MIN = 1
127: anything / INT65_MIN = 0
128: + / 0 = INT65_MAX (eh?)
129: - / 0 = INT65_MIN (eh?)
130: */
131: if (a.value == 0)
132: {
133: if (a.negative)
134: return SignExtendedNumber(value == 0 && negative);
135: else
136: return extreme(negative);
137: }
138:
139: uinteger_t aAbs = copySign(a.value, a.negative);
140: uinteger_t rvVal;
141:
142: if (!isMinimum())
143: rvVal = copySign(value, negative) / aAbs;
144: // Special handling for INT65_MIN
145: // if the denominator is not a power of 2, it is same as UINT64_MAX / x.
146: else if (aAbs & (aAbs-1))
147: rvVal = UINT64_MAX / aAbs;
148: // otherwise, it's the same as reversing the bits of x.
149: else
150: {
151: if (aAbs == 1)
152: return extreme(!a.negative);
153: rvVal = 1ULL << 63;
154: aAbs >>= 1;
155: if (aAbs & 0xAAAAAAAAAAAAAAAAULL) rvVal >>= 1;
156: if (aAbs & 0xCCCCCCCCCCCCCCCCULL) rvVal >>= 2;
157: if (aAbs & 0xF0F0F0F0F0F0F0F0ULL) rvVal >>= 4;
158: if (aAbs & 0xFF00FF00FF00FF00ULL) rvVal >>= 8;
159: if (aAbs & 0xFFFF0000FFFF0000ULL) rvVal >>= 16;
160: if (aAbs & 0xFFFFFFFF00000000ULL) rvVal >>= 32;
161: }
162: bool rvNeg = negative != a.negative;
163: rvVal = copySign(rvVal, rvNeg);
164:
165: return SignExtendedNumber(rvVal, rvVal != 0 && rvNeg);
166: }
167:
168: SignExtendedNumber SignExtendedNumber::operator%(const SignExtendedNumber& a) const
169: {
170: if (a.value == 0)
171: return !a.negative ? a : isMinimum() ? SignExtendedNumber(0) : *this;
172:
173: uinteger_t aAbs = copySign(a.value, a.negative);
174: uinteger_t rvVal;
175:
176: // a % b == sgn(a) * abs(a) % abs(b).
177: if (!isMinimum())
178: rvVal = copySign(value, negative) % aAbs;
179: // Special handling for INT65_MIN
180: // if the denominator is not a power of 2, it is same as UINT64_MAX%x + 1.
181: else if (aAbs & (aAbs - 1))
182: rvVal = UINT64_MAX % aAbs + 1;
183: // otherwise, the modulus is trivially zero.
184: else
185: rvVal = 0;
186:
187: rvVal = copySign(rvVal, negative);
188: return SignExtendedNumber(rvVal, rvVal != 0 && negative);
189: }
190:
191: SignExtendedNumber& SignExtendedNumber::operator++()
192: {
193: if (value != UINT64_MAX)
194: ++ value;
195: else if (negative)
196: {
197: value = 0;
198: negative = false;
199: }
200: return *this;
201: }
202:
203: SignExtendedNumber SignExtendedNumber::operator<<(const SignExtendedNumber& a) const
204: {
205: // assume left-shift the shift-amount is always unsigned. Thus negative
206: // shifts will give huge result.
207: if (value == 0)
208: return *this;
209: else if (a.negative)
210: return extreme(negative);
211:
212: uinteger_t v = copySign(value, negative);
213:
214: // compute base-2 log of 'v' to determine the maximum allowed bits to shift.
215: // Ref: http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
216:
217: size_t r, s;
218:
219: r = (v > 0xFFFFFFFFULL) << 5; v >>= r;
220: s = (v > 0xFFFFULL ) << 4; v >>= s; r |= s;
221: s = (v > 0xFFULL ) << 3; v >>= s; r |= s;
222: s = (v > 0xFULL ) << 2; v >>= s; r |= s;
223: s = (v > 0x3ULL ) << 1; v >>= s; r |= s;
224: r |= (v >> 1);
225:
226: uinteger_t allowableShift = 63 - r;
227: if (a.value > allowableShift)
228: return extreme(negative);
229: else
230: return SignExtendedNumber(value << a.value, negative);
231: }
232:
233: SignExtendedNumber SignExtendedNumber::operator>>(const SignExtendedNumber& a) const
234: {
235: if (a.negative || a.value > 64)
236: return negative ? SignExtendedNumber(-1, true) : SignExtendedNumber(0);
237: else if (isMinimum())
238: return a.value == 0 ? *this : SignExtendedNumber(-1ULL << (64-a.value), true);
warning C4146: unary minus operator applied to unsigned type, result still unsigned
239:
240: uinteger_t x = value ^ -negative;
warning C4804: '-' : unsafe use of type 'bool' in operation
241: x >>= a.value;
242: return SignExtendedNumber(x ^ -negative, negative);
warning C4804: '-' : unsafe use of type 'bool' in operation
243: }
244:
245:
246: //==================== IntRange ================================================
247:
248: IntRange IntRange::widest()
249: {
250: return IntRange(SignExtendedNumber::min(), SignExtendedNumber::max());
251: }
252:
253: #if !PERFORM_UNITTEST
254: IntRange IntRange::fromType(Type *type)
255: {
256: return fromType(type, type->isunsigned());
warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
257: }
258:
259: IntRange IntRange::fromType(Type *type, bool isUnsigned)
260: {
261: if (!type->isintegral())
262: return widest();
263:
264: uinteger_t mask = type->sizemask();
265: SignExtendedNumber lower(0), upper(mask);
266: if (type->toBasetype()->ty == Tdchar)
267: upper.value = 0x10FFFFULL;
268: else if (!isUnsigned)
269: {
270: lower.value = ~(mask >> 1);
271: lower.negative = true;
272: upper.value = (mask >> 1);
273: }
274: return IntRange(lower, upper);
275: }
276: #endif
277:
278: IntRange IntRange::fromNumbers2(const SignExtendedNumber numbers[2])
279: {
280: if (numbers[0] < numbers[1])
281: return IntRange(numbers[0], numbers[1]);
282: else
283: return IntRange(numbers[1], numbers[0]);
284: }
285: IntRange IntRange::fromNumbers4(const SignExtendedNumber numbers[4])
286: {
287: IntRange ab = fromNumbers2(numbers);
288: IntRange cd = fromNumbers2(numbers + 2);
289: if (cd.imin < ab.imin)
290: ab.imin = cd.imin;
291: if (cd.imax > ab.imax)
292: ab.imax = cd.imax;
293: return ab;
294: }
295:
296: bool IntRange::contains(const IntRange& a) const
297: {
298: return imin <= a.imin && imax >= a.imax;
299: }
300:
301: bool IntRange::containsZero() const
302: {
303: return (imin.negative && !imax.negative)
304: || (!imin.negative && imin.value == 0);
305: }
306:
307: IntRange& IntRange::castUnsigned(uinteger_t mask)
308: {
309: // .... 0x1eff ] [0x1f00 .. 0x1fff] [0 .. 0xff] [0x100 .. 0x1ff] [0x200 ....
310: //
311: // regular unsigned type. We just need to see if ir steps across the
312: // boundary of validRange. If yes, ir will represent the whole validRange,
313: // otherwise, we just take the modulus.
314: // e.g. [0x105, 0x107] & 0xff == [5, 7]
315: // [0x105, 0x207] & 0xff == [0, 0xff]
316: uinteger_t minChunk = imin.value & ~mask;
317: uinteger_t maxChunk = imax.value & ~mask;
318: if (minChunk == maxChunk && imin.negative == imax.negative)
319: {
320: imin.value &= mask;
321: imax.value &= mask;
322: }
323: else
324: {
325: imin.value = 0;
326: imax.value = mask;
327: }
328: imin.negative = imax.negative = false;
329: return *this;
330: }
331:
332: IntRange& IntRange::castSigned(uinteger_t mask)
333: {
334: // .... 0x1e7f ] [0x1e80 .. 0x1f7f] [0x1f80 .. 0x7f] [0x80 .. 0x17f] [0x180 ....
335: //
336: // regular signed type. We use a technique similar to the unsigned version,
337: // but the chunk has to be offset by 1/2 of the range.
338: uinteger_t halfChunkMask = mask >> 1;
339: uinteger_t minHalfChunk = imin.value & ~halfChunkMask;
340: uinteger_t maxHalfChunk = imax.value & ~halfChunkMask;
341: int minHalfChunkNegativity = imin.negative; // 1 = neg, 0 = nonneg, -1 = chunk containing ::max
342: int maxHalfChunkNegativity = imax.negative;
343: if (minHalfChunk & mask)
344: {
345: minHalfChunk += halfChunkMask+1;
346: if (minHalfChunk == 0)
347: -- minHalfChunkNegativity;
348: }
349: if (maxHalfChunk & mask)
350: {
351: maxHalfChunk += halfChunkMask+1;
352: if (maxHalfChunk == 0)
353: -- maxHalfChunkNegativity;
354: }
355: if (minHalfChunk == maxHalfChunk && minHalfChunkNegativity == maxHalfChunkNegativity)
356: {
357: imin.value &= mask;
358: imax.value &= mask;
359: // sign extend if necessary.
360: imin.negative = imin.value & ~halfChunkMask;
warning C4800: 'uinteger_t' : forcing value to bool 'true' or 'false' (performance warning)
361: imax.negative = imax.value & ~halfChunkMask;
warning C4800: 'uinteger_t' : forcing value to bool 'true' or 'false' (performance warning)
362: halfChunkMask += 1;
363: imin.value = (imin.value ^ halfChunkMask) - halfChunkMask;
364: imax.value = (imax.value ^ halfChunkMask) - halfChunkMask;
365: }
366: else
367: {
368: imin = SignExtendedNumber(~halfChunkMask, true);
369: imax = SignExtendedNumber(halfChunkMask, false);
370: }
371: return *this;
372: }
373:
374: IntRange& IntRange::castDchar()
375: {
376: // special case for dchar. Casting to dchar means "I'll ignore all
377: // invalid characters."
378: castUnsigned(0xFFFFFFFFULL);
379: if (imin.value > 0x10FFFFULL) // ??
380: imin.value = 0x10FFFFULL; // ??
381: if (imax.value > 0x10FFFFULL)
382: imax.value = 0x10FFFFULL;
383: return *this;
384: }
385:
386: #if !PERFORM_UNITTEST
387: IntRange& IntRange::cast(Type *type)
388: {
389: if (!type->isintegral())
390: return *this;
391: else if (!type->isunsigned())
392: return castSigned(type->sizemask());
393: else if (type->toBasetype()->ty == Tdchar)
394: return castDchar();
395: else
396: return castUnsigned(type->sizemask());
397: }
398:
399: IntRange& IntRange::castUnsigned(Type *type)
400: {
401: if (!type->isintegral())
402: return castUnsigned(UINT64_MAX);
403: else if (type->toBasetype()->ty == Tdchar)
404: return castDchar();
405: else
406: return castUnsigned(type->sizemask());
407: }
408: #endif
409:
410: IntRange IntRange::absNeg() const
411: {
412: if (imax.negative)
413: return *this;
414: else if (!imin.negative)
415: return IntRange(-imax, -imin);
416: else
417: {
418: SignExtendedNumber imaxAbsNeg = -imax;
419: return IntRange(imaxAbsNeg < imin ? imaxAbsNeg : imin,
420: SignExtendedNumber(0));
421: }
422: }
423:
424: IntRange IntRange::unionWith(const IntRange& other) const
425: {
426: return IntRange(imin < other.imin ? imin : other.imin,
427: imax > other.imax ? imax : other.imax);
428: }
429:
430: void IntRange::unionOrAssign(const IntRange& other, bool& union_)
431: {
432: if (!union_ || imin > other.imin)
433: imin = other.imin;
434: if (!union_ || imax < other.imax)
435: imax = other.imax;
436: union_ = true;
437: }
438:
439: void IntRange::splitBySign(IntRange& negRange, bool& hasNegRange,
440: IntRange& nonNegRange, bool& hasNonNegRange) const
441: {
442: hasNegRange = imin.negative;
443: if (hasNegRange)
444: {
445: negRange.imin = imin;
446: negRange.imax = imax.negative ? imax : SignExtendedNumber(-1, true);
447: }
448: hasNonNegRange = !imax.negative;
449: if (hasNonNegRange)
450: {
451: nonNegRange.imin = imin.negative ? SignExtendedNumber(0) : imin;
452: nonNegRange.imax = imax;
453: }
454: }
455:
456:
457: #if !PERFORM_UNITTEST
458: const IntRange& IntRange::dump(const char* funcName, Expression *e) const
459: {
460: printf("[(%c)%#018llx, (%c)%#018llx] @ %s ::: %s\n",
461: imin.negative?'-':'+', (unsigned long long)imin.value,
462: imax.negative?'-':'+', (unsigned long long)imax.value,
463: funcName, e->toChars());
464: return *this;
465: }
466: #endif
467:
468: //------------------------------------------------------------------------------
469:
470: #if PERFORM_UNITTEST
471: #include <cstdio>
472: #include <exception>
473:
474: class AssertionError : public std::exception {
475: public:
476: AssertionError() : std::exception() {}
477: };
478:
479: void _assertPred(uinteger_t x, uinteger_t y, int line) {
480: if (x != y) {
481: printf("Line %d: %#018llx != %#018llx\n", line, x, y);
482: throw AssertionError();
483: }
484: }
485: void _assertPred(const SignExtendedNumber& x, const SignExtendedNumber& y, int line) {
486: if (x != y) {
487: printf("Line %d: (%c)%#018llx != (%c)%#018llx\n", line,
488: x.negative?'-':'+', x.value,
489: y.negative?'-':'+', y.value);
490: throw AssertionError();
491: }
492: }
493: void _assertPred(bool x, bool y, int line) {
494: if (x != y) {
495: static const char* const names[] = {"false", "true"};
496: printf("Line %d: %s != %s\n", line, names[x], names[y]);
497: throw AssertionError();
498: }
499: }
500: #define assertPred(x, y) _assertPred(x, y, __LINE__)
501: #define RUN(testName) \
502: try { \
503: testName(); \
504: } catch (const AssertionError&) { \
505: printf("********" #testName " failed\n"); \
506: }
507:
508: void testAssertSanity() {
509: int saneCount = 0;
510:
511: printf("Testing 'assert' sanity. You should see 3 assertion failures below\n");
512:
513: assertPred(true, true);
514: try {
515: assertPred(true, false);
516: } catch (const AssertionError&) {
517: ++ saneCount;
518: }
519:
520: assertPred(4ULL, 4ULL);
521: try {
522: assertPred(3ULL, -3ULL);
523: } catch (const AssertionError&) {
524: ++ saneCount;
525: }
526:
527: assertPred(SignExtendedNumber(5, false), SignExtendedNumber(5, false));
528: try {
529: assertPred(SignExtendedNumber(4, false), SignExtendedNumber(4, true));
530: } catch (const AssertionError&) {
531: ++ saneCount;
532: }
533:
534: printf("--------------\n");
535:
536: if (saneCount != 3) throw AssertionError();
537: }
538:
539: void testNegation() {
540: SignExtendedNumber s (4);
541: SignExtendedNumber t = -s;
542: assertPred(t.value, -4ULL);
543: assertPred(t.negative, true);
544:
545: s = SignExtendedNumber::max();
546: t = -s;
547: assertPred(t.value, 1);
548: assertPred(t.negative, true);
549:
550: s = SignExtendedNumber::fromInteger(-4);
551: assertPred(s.value, -4ULL);
552: assertPred(s.negative, true);
553:
554: t = -s;
555: assertPred(t.value, 4);
556: assertPred(t.negative, false);
557:
558: s = SignExtendedNumber::min();
559: t = -s;
560: assertPred(t.value, UINT64_MAX);
561: assertPred(t.negative, false);
562:
563: s = SignExtendedNumber(0);
564: t = -s;
565: assertPred(t.value, 0);
566: assertPred(t.negative, false);
567: }
568:
569: void testCompare() {
570: SignExtendedNumber a = SignExtendedNumber::min();
571: SignExtendedNumber b = SignExtendedNumber(-5, true);
572: SignExtendedNumber c = SignExtendedNumber(0, false);
573: SignExtendedNumber d = SignExtendedNumber(5, false);
574: SignExtendedNumber e = SignExtendedNumber::max();
575:
576: assertPred(a == a, true);
577: assertPred(a != a, false);
578: assertPred(a < b, true);
579: assertPred(b < c, true);
580: assertPred(c < d, true);
581: assertPred(d < e, true);
582: assertPred(a < c, true);
583: assertPred(c < e, true);
584: assertPred(b < d, true);
585: assertPred(b < a, false);
586: assertPred(c < b, false);
587: assertPred(d < c, false);
588: assertPred(e < d, false);
589: assertPred(e < c, false);
590: assertPred(d < b, false);
591: assertPred(c < a, false);
592:
593: assertPred(a, a);
594: assertPred(SignExtendedNumber::extreme(false), SignExtendedNumber::max());
595: assertPred(SignExtendedNumber::extreme(true), SignExtendedNumber::min());
596: }
597:
598: void testAddition() {
599: assertPred(SignExtendedNumber(4, false) + SignExtendedNumber(8, false),
600: SignExtendedNumber(12, false));
601: assertPred(SignExtendedNumber(4, false) + SignExtendedNumber(-9, true),
602: SignExtendedNumber(-5, true));
603: assertPred(SignExtendedNumber(-9, true) + SignExtendedNumber(4, false),
604: SignExtendedNumber(-5, true));
605: assertPred(SignExtendedNumber(-4, true) + SignExtendedNumber(9, false),
606: SignExtendedNumber(5, false));
607: assertPred(SignExtendedNumber(9, false) + SignExtendedNumber(-4, true),
608: SignExtendedNumber(5, false));
609: assertPred(SignExtendedNumber(9, true) + SignExtendedNumber(-4, false),
610: SignExtendedNumber(5, false));
611: assertPred(SignExtendedNumber(-4, true) + SignExtendedNumber(-6, true),
612: SignExtendedNumber(-10, true));
613: assertPred(SignExtendedNumber::max() + SignExtendedNumber(1, false),
614: SignExtendedNumber::max());
615: assertPred(SignExtendedNumber(UINT64_MAX/2+1, false) + SignExtendedNumber(UINT64_MAX/2+1, false),
616: SignExtendedNumber::max());
617: assertPred(SignExtendedNumber::max() + SignExtendedNumber::min(),
618: SignExtendedNumber(-1, true));
619: assertPred(SignExtendedNumber::min() + SignExtendedNumber(-1, true),
620: SignExtendedNumber::min());
621: assertPred(SignExtendedNumber::max() + SignExtendedNumber::max(),
622: SignExtendedNumber::max());
623: assertPred(SignExtendedNumber::min() + SignExtendedNumber::min(),
624: SignExtendedNumber::min());
625: assertPred(SignExtendedNumber(1, true) + SignExtendedNumber(1, true),
626: SignExtendedNumber::min());
627:
628: SignExtendedNumber x(0);
629: assertPred(++x, SignExtendedNumber(1));
630: x = SignExtendedNumber(-1, true);
631: assertPred(++x, SignExtendedNumber(0));
632: x = SignExtendedNumber::min();
633: assertPred(++x, SignExtendedNumber(1, true));
634: x = SignExtendedNumber::max();
635: assertPred(++x, SignExtendedNumber::max());
636: }
637:
638: void testSubtraction() {
639: assertPred(SignExtendedNumber(4, false) - SignExtendedNumber(8, false),
640: SignExtendedNumber(-4, true));
641: assertPred(SignExtendedNumber(4, false) - SignExtendedNumber(-9, true),
642: SignExtendedNumber(13, false));
643: assertPred(SignExtendedNumber(-9, true) - SignExtendedNumber(4, false),
644: SignExtendedNumber(-13, true));
645: assertPred(SignExtendedNumber(-4, true) - SignExtendedNumber(9, false),
646: SignExtendedNumber(-13, true));
647: assertPred(SignExtendedNumber(9, false) - SignExtendedNumber(-4, true),
648: SignExtendedNumber(13, false));
649: assertPred(SignExtendedNumber(9, true) - SignExtendedNumber(-4, false),
650: SignExtendedNumber::min());
651: assertPred(SignExtendedNumber(-4, true) - SignExtendedNumber(-6, true),
652: SignExtendedNumber(2, false));
653: assertPred(SignExtendedNumber::max() - SignExtendedNumber(-1, true),
654: SignExtendedNumber::max());
655: assertPred(SignExtendedNumber::max() - SignExtendedNumber::max(),
656: SignExtendedNumber(0));
657: assertPred(SignExtendedNumber::max() - SignExtendedNumber::min(),
658: SignExtendedNumber::max());
659: assertPred(SignExtendedNumber::min() - SignExtendedNumber(1, false),
660: SignExtendedNumber::min());
661: assertPred(SignExtendedNumber(1, false) - SignExtendedNumber::min(),
662: SignExtendedNumber::max());
663: assertPred(SignExtendedNumber::min() - SignExtendedNumber::min(),
664: SignExtendedNumber(0));
665: assertPred(SignExtendedNumber(1, true) - SignExtendedNumber::min(),
666: SignExtendedNumber(1, false));
667: }
668:
669: void testMultiplication() {
670: assertPred(SignExtendedNumber(4, false) * SignExtendedNumber(8, false),
671: SignExtendedNumber(32, false));
672: assertPred(SignExtendedNumber(4, false) * SignExtendedNumber(-9, true),
673: SignExtendedNumber(-36, true));
674: assertPred(SignExtendedNumber(-9, true) * SignExtendedNumber(4, false),
675: SignExtendedNumber(-36, true));
676: assertPred(SignExtendedNumber(-4, true) * SignExtendedNumber(9, false),
677: SignExtendedNumber(-36, true));
678: assertPred(SignExtendedNumber(9, false) * SignExtendedNumber(-4, true),
679: SignExtendedNumber(-36, true));
680: assertPred(SignExtendedNumber(9, true) * SignExtendedNumber(-4, false),
681: SignExtendedNumber::min());
682: assertPred(SignExtendedNumber(-4, true) * SignExtendedNumber(-6, true),
683: SignExtendedNumber(24, false));
684: assertPred(SignExtendedNumber::max() * SignExtendedNumber::max(),
685: SignExtendedNumber::max());
686: assertPred(SignExtendedNumber::max() * SignExtendedNumber(0),
687: SignExtendedNumber(0));
688: assertPred(SignExtendedNumber::max() * SignExtendedNumber::min(),
689: SignExtendedNumber::min());
690: assertPred(SignExtendedNumber(0) * SignExtendedNumber::max(),
691: SignExtendedNumber(0));
692: assertPred(SignExtendedNumber(0) * SignExtendedNumber(0),
693: SignExtendedNumber(0));
694: assertPred(SignExtendedNumber(0) * SignExtendedNumber::min(),
695: SignExtendedNumber(0));
696: assertPred(SignExtendedNumber::min() * SignExtendedNumber::max(),
697: SignExtendedNumber::min());
698: assertPred(SignExtendedNumber::min() * SignExtendedNumber(0),
699: SignExtendedNumber(0));
700: assertPred(SignExtendedNumber::min() * SignExtendedNumber::min(),
701: SignExtendedNumber::max());
702: assertPred(SignExtendedNumber(-6, false) * SignExtendedNumber(2, false),
703: SignExtendedNumber::max());
704: assertPred(SignExtendedNumber(-6, false) * SignExtendedNumber(-2, true),
705: SignExtendedNumber::min());
706: assertPred(SignExtendedNumber::max() * SignExtendedNumber(-1, true),
707: SignExtendedNumber(1, true));
708: assertPred(SignExtendedNumber::max() * SignExtendedNumber(-2, true),
709: SignExtendedNumber::min());
710: assertPred(SignExtendedNumber::max() * SignExtendedNumber(2, false),
711: SignExtendedNumber::max());
712: assertPred(SignExtendedNumber::min() * SignExtendedNumber(2, false),
713: SignExtendedNumber::min());
714: assertPred(SignExtendedNumber::min() * SignExtendedNumber(-1, true),
715: SignExtendedNumber::max());
716: }
717:
718: void testDivision() {
719: assertPred(SignExtendedNumber(4, false) / SignExtendedNumber(8, false),
720: SignExtendedNumber(0));
721: assertPred(SignExtendedNumber(8, false) / SignExtendedNumber(4, false),
722: SignExtendedNumber(2, false));
723: assertPred(SignExtendedNumber(4, false) / SignExtendedNumber(-9, true),
724: SignExtendedNumber(0));
725: assertPred(SignExtendedNumber(-9, true) / SignExtendedNumber(4, false),
726: SignExtendedNumber(-2, true));
727: assertPred(SignExtendedNumber(-4, true) / SignExtendedNumber(9, false),
728: SignExtendedNumber(0));
729: assertPred(SignExtendedNumber(9, false) / SignExtendedNumber(-4, true),
730: SignExtendedNumber(-2, true));
731: assertPred(SignExtendedNumber(4, true) / SignExtendedNumber(-9, false),
732: SignExtendedNumber(-1, true));
733: assertPred(SignExtendedNumber(-6, true) / SignExtendedNumber(-4, true),
734: SignExtendedNumber(1, false));
735: assertPred(SignExtendedNumber::max() / SignExtendedNumber::max(),
736: SignExtendedNumber(1));
737: assertPred(SignExtendedNumber::max() / SignExtendedNumber(0),
738: SignExtendedNumber::max());
739: assertPred(SignExtendedNumber::max() / SignExtendedNumber::min(),
740: SignExtendedNumber(0));
741: assertPred(SignExtendedNumber(0) / SignExtendedNumber::max(),
742: SignExtendedNumber(0));
743: assertPred(SignExtendedNumber(0) / SignExtendedNumber(0),
744: SignExtendedNumber::max());
745: assertPred(SignExtendedNumber(0) / SignExtendedNumber::min(),
746: SignExtendedNumber(0));
747: assertPred(SignExtendedNumber::min() / SignExtendedNumber::max(),
748: SignExtendedNumber(-1, true));
749: assertPred(SignExtendedNumber::min() / SignExtendedNumber(0),
750: SignExtendedNumber::min());
751: assertPred(SignExtendedNumber::min() / SignExtendedNumber::min(),
752: SignExtendedNumber(1));
753: assertPred(SignExtendedNumber(-6, false) / SignExtendedNumber(2, false),
754: SignExtendedNumber((~5ULL)>>1));
755: assertPred(SignExtendedNumber(-6, false) / SignExtendedNumber(-2, true),
756: SignExtendedNumber(3 | 1ULL<<63, true));
757: assertPred(SignExtendedNumber::max() / SignExtendedNumber(-1, true),
758: SignExtendedNumber(1, true));
759: assertPred(SignExtendedNumber::min() / SignExtendedNumber(-1, true),
760: SignExtendedNumber::max());
761: assertPred(SignExtendedNumber::max() / SignExtendedNumber(1, false),
762: SignExtendedNumber::max());
763: assertPred(SignExtendedNumber::min() / SignExtendedNumber(1, false),
764: SignExtendedNumber::min());
765: assertPred(SignExtendedNumber::min() / SignExtendedNumber(2, false),
766: SignExtendedNumber(-(1ULL << 63), true));
767: assertPred(SignExtendedNumber::min() / SignExtendedNumber(-1024, true),
768: SignExtendedNumber(1ULL << 54));
769: }
770:
771: void testModulus() {
772: assertPred(SignExtendedNumber(4, false) % SignExtendedNumber(8, false),
773: SignExtendedNumber(4, false));
774: assertPred(SignExtendedNumber(8, false) % SignExtendedNumber(4, false),
775: SignExtendedNumber(0));
776: assertPred(SignExtendedNumber(4, false) % SignExtendedNumber(-9, true),
777: SignExtendedNumber(4, false));
778: assertPred(SignExtendedNumber(-9, true) % SignExtendedNumber(4, false),
779: SignExtendedNumber(-1, true));
780: assertPred(SignExtendedNumber(-4, true) % SignExtendedNumber(9, false),
781: SignExtendedNumber(-4, true));
782: assertPred(SignExtendedNumber(9, false) % SignExtendedNumber(-4, true),
783: SignExtendedNumber(1, false));
784: assertPred(SignExtendedNumber(4, true) % SignExtendedNumber(-9, false),
785: SignExtendedNumber(-5, true));
786: assertPred(SignExtendedNumber(-6, true) % SignExtendedNumber(-4, true),
787: SignExtendedNumber(-2, true));
788: assertPred(SignExtendedNumber::max() % SignExtendedNumber::max(),
789: SignExtendedNumber(0));
790: assertPred(SignExtendedNumber::max() % SignExtendedNumber(0),
791: SignExtendedNumber(0));
792: assertPred(SignExtendedNumber::max() % SignExtendedNumber::min(),
793: SignExtendedNumber::max());
794: assertPred(SignExtendedNumber(0) % SignExtendedNumber::max(),
795: SignExtendedNumber(0));
796: assertPred(SignExtendedNumber(0) % SignExtendedNumber(0),
797: SignExtendedNumber(0));
798: assertPred(SignExtendedNumber(0) % SignExtendedNumber::min(),
799: SignExtendedNumber(0));
800: assertPred(SignExtendedNumber::min() % SignExtendedNumber::max(),
801: SignExtendedNumber(-1, true));
802: assertPred(SignExtendedNumber::min() % SignExtendedNumber(0),
803: SignExtendedNumber(0));
804: assertPred(SignExtendedNumber::min() % SignExtendedNumber::min(),
805: SignExtendedNumber(0));
806: assertPred(SignExtendedNumber(-6, false) % SignExtendedNumber(2, false),
807: SignExtendedNumber(0));
808: assertPred(SignExtendedNumber(-6, false) % SignExtendedNumber(-2, true),
809: SignExtendedNumber(0));
810: assertPred(SignExtendedNumber::max() % SignExtendedNumber(-1, true),
811: SignExtendedNumber(0));
812: assertPred(SignExtendedNumber::min() % SignExtendedNumber(-1, true),
813: SignExtendedNumber(0));
814: assertPred(SignExtendedNumber::max() % SignExtendedNumber(1, false),
815: SignExtendedNumber(0));
816: assertPred(SignExtendedNumber::min() % SignExtendedNumber(1, false),
817: SignExtendedNumber(0));
818: assertPred(SignExtendedNumber::min() % SignExtendedNumber(2, false),
819: SignExtendedNumber(0));
820: assertPred(SignExtendedNumber::min() % SignExtendedNumber(999, false),
821: SignExtendedNumber(-160, true));
822: }
823:
824: void testShift() {
825: assertPred(SignExtendedNumber(0) << SignExtendedNumber(4),
826: SignExtendedNumber(0));
827: assertPred(SignExtendedNumber(0) << SignExtendedNumber(74),
828: SignExtendedNumber(0));
829: assertPred(SignExtendedNumber(0) << SignExtendedNumber(-5, true),
830: SignExtendedNumber(0));
831: assertPred(SignExtendedNumber(0) << SignExtendedNumber::max(),
832: SignExtendedNumber(0));
833: assertPred(SignExtendedNumber(0) << SignExtendedNumber::min(),
834: SignExtendedNumber(0));
835: assertPred(SignExtendedNumber(1) << SignExtendedNumber(4),
836: SignExtendedNumber(16));
837: assertPred(SignExtendedNumber(1) << SignExtendedNumber(74),
838: SignExtendedNumber::max());
839: assertPred(SignExtendedNumber(1) << SignExtendedNumber(-5, true),
840: SignExtendedNumber::max());
841: assertPred(SignExtendedNumber(1) << SignExtendedNumber::max(),
842: SignExtendedNumber::max());
843: assertPred(SignExtendedNumber(1) << SignExtendedNumber::min(),
844: SignExtendedNumber::max());
845: assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber(4),
846: SignExtendedNumber(-16, true));
847: assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber(74),
848: SignExtendedNumber::min());
849: assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber(-5, true),
850: SignExtendedNumber::min());
851: assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber::max(),
852: SignExtendedNumber::min());
853: assertPred(SignExtendedNumber(-1, true) << SignExtendedNumber::min(),
854: SignExtendedNumber::min());
855: assertPred(SignExtendedNumber(0xabcdef) << SignExtendedNumber(12, false),
856: SignExtendedNumber(0xabcdef000ULL));
857: assertPred(SignExtendedNumber(0xabcdef) << SignExtendedNumber(40, false),
858: SignExtendedNumber(0xabcdef0000000000ULL));
859: assertPred(SignExtendedNumber(0xabcdef) << SignExtendedNumber(41, false),
860: SignExtendedNumber::max());
861:
862:
863: assertPred(SignExtendedNumber(0) >> SignExtendedNumber(4),
864: SignExtendedNumber(0));
865: assertPred(SignExtendedNumber(0) >> SignExtendedNumber(74),
866: SignExtendedNumber(0));
867: assertPred(SignExtendedNumber(0) >> SignExtendedNumber(-5, true),
868: SignExtendedNumber(0));
869: assertPred(SignExtendedNumber(0) >> SignExtendedNumber::max(),
870: SignExtendedNumber(0));
871: assertPred(SignExtendedNumber(0) >> SignExtendedNumber::min(),
872: SignExtendedNumber(0));
873: assertPred(SignExtendedNumber(16) >> SignExtendedNumber(4),
874: SignExtendedNumber(1));
875: assertPred(SignExtendedNumber(16) >> SignExtendedNumber(74),
876: SignExtendedNumber(0));
877: assertPred(SignExtendedNumber(16) >> SignExtendedNumber(-5, true),
878: SignExtendedNumber(0));
879: assertPred(SignExtendedNumber(16) >> SignExtendedNumber::max(),
880: SignExtendedNumber(0));
881: assertPred(SignExtendedNumber(16) >> SignExtendedNumber::min(),
882: SignExtendedNumber(0));
883: assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber(4),
884: SignExtendedNumber(-2, true));
885: assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber(74),
886: SignExtendedNumber(-1, true));
887: assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber(-5, true),
888: SignExtendedNumber(-1, true));
889: assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber::max(),
890: SignExtendedNumber(-1, true));
891: assertPred(SignExtendedNumber(-32, true) >> SignExtendedNumber::min(),
892: SignExtendedNumber(-1, true));
893: assertPred(SignExtendedNumber(0xabcdef, false) >> SignExtendedNumber(12, false),
894: SignExtendedNumber(0xabcULL));
895: assertPred(SignExtendedNumber(0xabcdef, true) >> SignExtendedNumber(12, false),
896: SignExtendedNumber(0xFFF0000000000ABCULL, true));
897: assertPred(SignExtendedNumber::min() >> SignExtendedNumber(1, false),
898: SignExtendedNumber(0x8000000000000000ULL, true));
899: assertPred(SignExtendedNumber::min() >> SignExtendedNumber(63, false),
900: SignExtendedNumber(-2, true));
901: assertPred(SignExtendedNumber::min() >> SignExtendedNumber(65, false),
902: SignExtendedNumber(-1, true));
903: }
904:
905: void testFromNumbers() {
906: SignExtendedNumber a[] = {
907: SignExtendedNumber(12, false),
908: SignExtendedNumber(-35, true),
909: SignExtendedNumber(40, false),
910: SignExtendedNumber(-21, true),
911: SignExtendedNumber::min()
912: };
913:
914: IntRange ir1 = IntRange::fromNumbers2(a);
915: assertPred(ir1.imin, SignExtendedNumber(-35, true));
916: assertPred(ir1.imax, SignExtendedNumber(12, false));
917:
918: IntRange ir2 = IntRange::fromNumbers2(a+1);
919: assertPred(ir2.imin, SignExtendedNumber(-35, true));
920: assertPred(ir2.imax, SignExtendedNumber(40, false));
921:
922: IntRange ir3 = IntRange::fromNumbers4(a);
923: assertPred(ir3.imin, SignExtendedNumber(-35, true));
924: assertPred(ir3.imax, SignExtendedNumber(40, false));
925:
926: IntRange ir4 = IntRange::fromNumbers4(a+1);
927: assertPred(ir4.imin, SignExtendedNumber::min());
928: assertPred(ir4.imax, SignExtendedNumber(40, false));
929:
930: assertPred(ir4.contains(ir3), true);
931: assertPred(ir1.contains(ir2), false);
932:
933: IntRange ir5 = IntRange::widest();
934: assertPred(ir5.imin, SignExtendedNumber::min());
935: assertPred(ir5.imax, SignExtendedNumber::max());
936: assertPred(ir5.contains(ir4), true);
937: }
938:
939: void testContainsZero() {
940: IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(4));
941: assertPred(ir1.containsZero(), true);
942:
943: IntRange ir2 (SignExtendedNumber(-4, true), SignExtendedNumber(0));
944: assertPred(ir2.containsZero(), true);
945:
946: IntRange ir3 (SignExtendedNumber(-5, true), SignExtendedNumber(5));
947: assertPred(ir3.containsZero(), true);
948:
949: assertPred(IntRange::widest().containsZero(), true);
950:
951: IntRange ir4 (SignExtendedNumber(8), SignExtendedNumber(9));
952: assertPred(ir4.containsZero(), false);
953:
954: IntRange ir5 (SignExtendedNumber(-5, true), SignExtendedNumber(-2, true));
955: assertPred(ir5.containsZero(), false);
956:
957: IntRange ir6 (SignExtendedNumber(0), SignExtendedNumber(0));
958: assertPred(ir6.containsZero(), true);
959: }
960:
961: void testCast() {
962: {
963: IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(0xFFFF));
964: ir1.castUnsigned(0xFF);
965: assertPred(ir1.imin, SignExtendedNumber(0));
966: assertPred(ir1.imax, SignExtendedNumber(0xFF));
967:
968: IntRange ir2 (SignExtendedNumber(0x101), SignExtendedNumber(0x105));
969: ir2.castUnsigned(0xFF);
970: assertPred(ir2.imin, SignExtendedNumber(1));
971: assertPred(ir2.imax, SignExtendedNumber(5));
972:
973: IntRange ir3 (SignExtendedNumber(-7, true), SignExtendedNumber(7, false));
974: ir3.castUnsigned(0xFF);
975: assertPred(ir3.imin, SignExtendedNumber(0));
976: assertPred(ir3.imax, SignExtendedNumber(0xFF));
977:
978: IntRange ir4 (SignExtendedNumber(0x997F), SignExtendedNumber(0x9999));
979: ir4.castUnsigned(0xFF);
980: assertPred(ir4.imin, SignExtendedNumber(0x7F));
981: assertPred(ir4.imax, SignExtendedNumber(0x99));
982:
983: IntRange ir5 (SignExtendedNumber(-1, true), SignExtendedNumber(1, false));
984: ir5.castUnsigned(UINT64_MAX);
985: assertPred(ir5.imin, SignExtendedNumber(0));
986: assertPred(ir5.imax, SignExtendedNumber::max());
987:
988: IntRange ir6 (SignExtendedNumber::min(), SignExtendedNumber(0));
989: ir6.castUnsigned(UINT64_MAX);
990: assertPred(ir6.imin, SignExtendedNumber(0));
991: assertPred(ir6.imax, SignExtendedNumber::max());
992:
993: IntRange ir7 (SignExtendedNumber::min(), SignExtendedNumber(-0x80, true));
994: ir7.castUnsigned(UINT64_MAX);
995: assertPred(ir7.imin, SignExtendedNumber(0));
996: assertPred(ir7.imax, SignExtendedNumber(-0x80, false));
997:
998: IntRange ir8 = IntRange::widest();
999: ir8.castUnsigned(0xFF);
1000: assertPred(ir8.imin, SignExtendedNumber(0));
1001: assertPred(ir8.imax, SignExtendedNumber(0xFF));
1002: }
1003:
1004: {
1005: IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(0xFFFF));
1006: ir1.castSigned(0xFF);
1007: assertPred(ir1.imin, SignExtendedNumber(-0x80, true));
1008: assertPred(ir1.imax, SignExtendedNumber(0x7F, false));
1009:
1010: IntRange ir2 (SignExtendedNumber(0x101), SignExtendedNumber(0x105));
1011: ir2.castSigned(0xFF);
1012: assertPred(ir2.imin, SignExtendedNumber(1));
1013: assertPred(ir2.imax, SignExtendedNumber(5));
1014:
1015: IntRange ir3 (SignExtendedNumber(-7, true), SignExtendedNumber(7, false));
1016: ir3.castSigned(0xFF);
1017: assertPred(ir3.imin, SignExtendedNumber(-7, true));
1018: assertPred(ir3.imax, SignExtendedNumber(7, false));
1019:
1020: IntRange ir4 (SignExtendedNumber(0x997F), SignExtendedNumber(0x9999));
1021: ir4.castSigned(0xFF);
1022: assertPred(ir4.imin, SignExtendedNumber(-0x80, true));
1023: assertPred(ir4.imax, SignExtendedNumber(0x7F, false));
1024:
1025: IntRange ir5 (SignExtendedNumber(-0xFF, true), SignExtendedNumber(-0x80, true));
1026: ir5.castSigned(0xFF);
1027: assertPred(ir5.imin, SignExtendedNumber(-0x80, true));
1028: assertPred(ir5.imax, SignExtendedNumber(0x7F, false));
1029:
1030: IntRange ir6 (SignExtendedNumber(-0x80, true), SignExtendedNumber(-0x80, true));
1031: ir6.castSigned(0xFF);
1032: assertPred(ir6.imin, SignExtendedNumber(-0x80, true));
1033: assertPred(ir6.imax, SignExtendedNumber(-0x80, true));
1034:
1035: IntRange ir7 = IntRange::widest();
1036: ir7.castSigned(0xFFFFFFFFULL);
1037: assertPred(ir7.imin, SignExtendedNumber(-0x80000000ULL, true));
1038: assertPred(ir7.imax, SignExtendedNumber( 0x7FFFFFFFULL, false));
1039: }
1040:
1041: {
1042: IntRange ir1 (SignExtendedNumber(0), SignExtendedNumber(0x9999));
1043: ir1.castDchar();
1044: assertPred(ir1.imin, SignExtendedNumber(0));
1045: assertPred(ir1.imax, SignExtendedNumber(0x9999));
1046:
1047: IntRange ir2 (SignExtendedNumber(0xFFFF), SignExtendedNumber(0x7FFFFFFF));
1048: ir2.castDchar();
1049: assertPred(ir2.imin, SignExtendedNumber(0xFFFF));
1050: assertPred(ir2.imax, SignExtendedNumber(0x10FFFF));
1051:
1052: IntRange ir3 = IntRange::widest();
1053: ir3.castDchar();
1054: assertPred(ir3.imin, SignExtendedNumber(0));
1055: assertPred(ir3.imax, SignExtendedNumber(0x10FFFF));
1056: }
1057: }
1058:
1059: void testAbsNeg() {
1060: IntRange ir1 = IntRange(SignExtendedNumber(5), SignExtendedNumber(104)).absNeg();
1061: assertPred(ir1.imin, SignExtendedNumber(-104, true));
1062: assertPred(ir1.imax, SignExtendedNumber(-5, true));
1063:
1064: IntRange ir2 = IntRange(SignExtendedNumber(-46, true), SignExtendedNumber(-3, true)).absNeg();
1065: assertPred(ir2.imin, SignExtendedNumber(-46, true));
1066: assertPred(ir2.imax, SignExtendedNumber(-3, true));
1067:
1068: IntRange ir3 = IntRange(SignExtendedNumber(-7, true), SignExtendedNumber(9)).absNeg();
1069: assertPred(ir3.imin, SignExtendedNumber(-9, true));
1070: assertPred(ir3.imax, SignExtendedNumber(0));
1071:
1072: IntRange ir4 = IntRange(SignExtendedNumber(-12, true), SignExtendedNumber(2)).absNeg();
1073: assertPred(ir4.imin, SignExtendedNumber(-12, true));
1074: assertPred(ir4.imax, SignExtendedNumber(0));
1075:
1076: IntRange ir5 = IntRange::widest().absNeg();
1077: assertPred(ir5.imin, SignExtendedNumber::min());
1078: assertPred(ir5.imax, SignExtendedNumber(0));
1079:
1080: IntRange ir6 = IntRange(SignExtendedNumber(0), SignExtendedNumber::max()).absNeg();
1081: assertPred(ir6.imin, SignExtendedNumber(1, true));
1082: assertPred(ir6.imax, SignExtendedNumber(0));
1083: }
1084:
1085: int main() {
1086: RUN(testAssertSanity);
1087: RUN(testNegation);
1088: RUN(testCompare);
1089: RUN(testAddition);
1090: RUN(testSubtraction);
1091: RUN(testMultiplication);
1092: RUN(testDivision);
1093: RUN(testModulus);
1094: RUN(testShift);
1095: RUN(testFromNumbers);
1096: RUN(testContainsZero);
1097: RUN(testCast);
1098: RUN(testAbsNeg);
1099: printf("Finished all tests.\n");
1100: }
1101:
1102:
1103: #endif
1104:
1105:
1106: