1 #include "flang/Evaluate/integer.h"
2 #include "testing.h"
3 #include <cstdio>
4 #include <string>
5 
6 using Fortran::evaluate::Ordering;
7 using Fortran::evaluate::value::Integer;
8 
9 template <int BITS, typename INT = Integer<BITS>> void exhaustiveTesting() {
10   std::uint64_t maxUnsignedValue{(std::uint64_t{1} << BITS) - 1};
11   std::int64_t maxPositiveSignedValue{(std::int64_t{1} << (BITS - 1)) - 1};
12   std::int64_t mostNegativeSignedValue{-(std::int64_t{1} << (BITS - 1))};
13   char desc[64];
14   std::snprintf(desc, sizeof desc,
15       "BITS=%d, PARTBITS=%d, sizeof(Part)=%d, LE=%d", BITS, INT::partBits,
16       static_cast<int>(sizeof(typename INT::Part)), INT::littleEndian);
17 
18   MATCH(BITS, INT::bits)(desc);
19   MATCH(maxPositiveSignedValue, INT::HUGE().ToUInt64())(desc);
20   INT zero;
21   TEST(zero.IsZero())(desc);
22   MATCH(0, zero.ToUInt64())(desc);
23   MATCH(0, zero.ToInt64())(desc);
24 
25   for (std::uint64_t x{0}; x <= maxUnsignedValue; ++x) {
26     unsigned long long ullx = x;
27     INT a{x};
28     MATCH(x, a.ToUInt64())(desc);
29     INT copy{a};
30     MATCH(x, copy.ToUInt64())(desc);
31     copy = a;
32     MATCH(x, copy.ToUInt64())(desc);
33     MATCH(x == 0, a.IsZero())("%s, x=0x%llx", desc, x);
34     char buffer[64];
35     std::snprintf(buffer, sizeof buffer, "   %llu", ullx);
36     const char *p{buffer};
37     auto readcheck{INT::Read(p)};
38     TEST(!readcheck.overflow)("%s, x=0x%llx", desc, x);
39     MATCH(x, readcheck.value.ToUInt64())("%s, x=0x%llx", desc, x);
40     TEST(!*p)("%s, x=0x%llx", desc, x);
41     std::snprintf(buffer, sizeof buffer, "%llx", ullx);
42     p = buffer;
43     readcheck = INT::Read(p, 16);
44     TEST(!readcheck.overflow)("%s, x=0x%llx", desc, x);
45     MATCH(x, readcheck.value.ToUInt64())("%s, x=0x%llx", desc, x);
46     TEST(!*p)("%s, x=0x%llx", desc, x);
47     std::string udec{a.UnsignedDecimal()};
48     p = udec.data();
49     readcheck = INT::Read(p);
50     TEST(!readcheck.overflow)("%s, x=0x%llx", desc, x);
51     MATCH(x, readcheck.value.ToUInt64())("%s, x=0x%llx", desc, x);
52     TEST(!*p)("%s, x=0x%llx", desc, x);
53     std::string hex{a.Hexadecimal()};
54     p = hex.data();
55     readcheck = INT::Read(p, 16);
56     TEST(!readcheck.overflow)("%s, x=0x%llx", desc, x);
57     MATCH(x, readcheck.value.ToUInt64())("%s, x=0x%llx", desc, x);
58     TEST(!*p)("%s, x=0x%llx", desc, x);
59     INT t{a.NOT()};
60     MATCH(x ^ maxUnsignedValue, t.ToUInt64())("%s, x=0x%llx", desc, x);
61     auto negated{a.Negate()};
62     MATCH(x == std::uint64_t{1} << (BITS - 1), negated.overflow)
63     ("%s, x=0x%llx", desc, x);
64     MATCH(-x & maxUnsignedValue, negated.value.ToUInt64())
65     ("%s, x=0x%llx", desc, x);
66     auto abs{a.ABS()};
67     MATCH(x == std::uint64_t{1} << (BITS - 1), abs.overflow)
68     ("%s, x=0x%llx", desc, x);
69     MATCH(x >> (BITS - 1) ? -x & maxUnsignedValue : x, abs.value.ToUInt64())
70     ("%s, x=0x%llx", desc, x);
71     int lzbc{a.LEADZ()};
72     COMPARE(lzbc, >=, 0)("%s, x=0x%llx", desc, x);
73     COMPARE(lzbc, <=, BITS)("%s, x=0x%llx", desc, x);
74     MATCH(x == 0, lzbc == BITS)("%s, x=0x%llx, lzbc=%d", desc, x, lzbc);
75     std::uint64_t lzcheck{std::uint64_t{1} << (BITS - lzbc)};
76     COMPARE(x, <, lzcheck)("%s, x=0x%llx, lzbc=%d", desc, x, lzbc);
77     COMPARE(x + x + !x, >=, lzcheck)("%s, x=0x%llx, lzbc=%d", desc, x, lzbc);
78     int popcheck{0};
79     for (int j{0}; j < BITS; ++j) {
80       popcheck += (x >> j) & 1;
81     }
82     MATCH(popcheck, a.POPCNT())("%s, x=0x%llx", desc, x);
83     MATCH(popcheck & 1, a.POPPAR())("%s, x=0x%llx", desc, x);
84     int trailcheck{0};
85     for (; trailcheck < BITS; ++trailcheck) {
86       if ((x >> trailcheck) & 1) {
87         break;
88       }
89     }
90     MATCH(trailcheck, a.TRAILZ())("%s, x=0x%llx", desc, x);
91     for (int j{0}; j < BITS; ++j) {
92       MATCH((x >> j) & 1, a.BTEST(j))
93       ("%s, x=0x%llx, bit %d", desc, x, j);
94     }
95     // TODO test DIM, MODULO, ISHFTC, DSHIFTL/R
96     // TODO test IBCLR, IBSET, IBITS, MAX, MIN, MERGE_BITS, RANGE, SIGN
97 
98     Ordering ord{Ordering::Equal};
99     std::int64_t sx = x;
100     if (x + x > maxUnsignedValue) {
101       TEST(a.IsNegative())("%s, x=0x%llx", desc, x);
102       sx = x | (~std::uint64_t{0} << BITS);
103       TEST(sx < 0)("%s, x=0x%llx %lld", desc, x, sx);
104       ord = Ordering::Less;
105     } else {
106       TEST(!a.IsNegative())("%s, x=0x%llx", desc, x);
107       TEST(sx >= 0)("%s, x=0x%llx %lld", desc, x, sx);
108       if (sx > 0) {
109         ord = Ordering::Greater;
110       } else {
111         ord = Ordering::Equal;
112       }
113     }
114 
115     TEST(sx == a.ToInt64())("%s, x=0x%llx %lld", desc, x, sx);
116     TEST(a.CompareToZeroSigned() == ord)("%s, x=0x%llx %lld", desc, x, sx);
117     for (int count{0}; count <= BITS + 1; ++count) {
118       t = a.SHIFTL(count);
119       MATCH((x << count) & maxUnsignedValue, t.ToUInt64())
120       ("%s, x=0x%llx, count=%d", desc, x, count);
121       t = a.ISHFT(count);
122       MATCH((x << count) & maxUnsignedValue, t.ToUInt64())
123       ("%s, x=0x%llx, count=%d", desc, x, count);
124       t = a.SHIFTR(count);
125       MATCH(x >> count, t.ToUInt64())
126       ("%s, x=0x%llx, count=%d", desc, x, count);
127       t = a.ISHFT(-count);
128       MATCH(x >> count, t.ToUInt64())("%s, x=0x%llx, count=%d", desc, x, count);
129       t = a.SHIFTA(count);
130       std::uint64_t fill{-(x >> (BITS - 1))};
131       std::uint64_t sra{
132           count >= BITS ? fill : (x >> count) | (fill << (BITS - count))};
133       MATCH(sra, t.ToInt64())
134       ("%s, x=0x%llx, count=%d", desc, x, count);
135     }
136 
137     for (std::uint64_t y{0}; y <= maxUnsignedValue; ++y) {
138       std::int64_t sy = y;
139       if (y + y > maxUnsignedValue) {
140         sy = y | (~std::uint64_t{0} << BITS);
141       }
142       INT b{y};
143       if (x < y) {
144         ord = Ordering::Less;
145       } else if (x > y) {
146         ord = Ordering::Greater;
147       } else {
148         ord = Ordering::Equal;
149       }
150       TEST(a.CompareUnsigned(b) == ord)("%s, x=0x%llx, y=0x%llx", desc, x, y);
151       MATCH(x >= y, a.BGE(b))("%s, x=0x%llx, y=0x%llx", desc, x, y);
152       MATCH(x > y, a.BGT(b))("%s, x=0x%llx, y=0x%llx", desc, x, y);
153       MATCH(x <= y, a.BLE(b))("%s, x=0x%llx, y=0x%llx", desc, x, y);
154       MATCH(x < y, a.BLT(b))("%s, x=0x%llx, y=0x%llx", desc, x, y);
155       if (sx < sy) {
156         ord = Ordering::Less;
157       } else if (sx > sy) {
158         ord = Ordering::Greater;
159       } else {
160         ord = Ordering::Equal;
161       }
162       TEST(a.CompareSigned(b) == ord)
163       ("%s, x=0x%llx %lld %d, y=0x%llx %lld %d", desc, x, sx, a.IsNegative(), y,
164           sy, b.IsNegative());
165 
166       t = a.IAND(b);
167       MATCH(x & y, t.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y);
168       t = a.IOR(b);
169       MATCH(x | y, t.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y);
170       t = a.IEOR(b);
171       MATCH(x ^ y, t.ToUInt64())("%s, x=0x%llx, y=0x%llx", desc, x, y);
172       auto sum{a.AddUnsigned(b)};
173       COMPARE(
174           x + y, ==, sum.value.ToUInt64() + (std::uint64_t{sum.carry} << BITS))
175       ("%s, x=0x%llx, y=0x%llx, carry=%d", desc, x, y, sum.carry);
176       auto ssum{a.AddSigned(b)};
177       MATCH((sx + sy) & maxUnsignedValue, ssum.value.ToUInt64())
178       ("%s, x=0x%llx, y=0x%llx", desc, x, y);
179       MATCH(
180           sx + sy < mostNegativeSignedValue || sx + sy > maxPositiveSignedValue,
181           ssum.overflow)
182       ("%s, x=0x%llx, y=0x%llx", desc, x, y);
183       auto diff{a.SubtractSigned(b)};
184       MATCH((sx - sy) & maxUnsignedValue, diff.value.ToUInt64())
185       ("%s, x=0x%llx, y=0x%llx", desc, x, y);
186       MATCH(
187           sx - sy < mostNegativeSignedValue || sx - sy > maxPositiveSignedValue,
188           diff.overflow)
189       ("%s, x=0x%llx, y=0x%llx", desc, x, y);
190       auto product{a.MultiplyUnsigned(b)};
191       MATCH(
192           x * y, (product.upper.ToUInt64() << BITS) ^ product.lower.ToUInt64())
193       ("%s, x=0x%llx, y=0x%llx, lower=0x%llx, upper=0x%llx", desc, x, y,
194           product.lower.ToUInt64(), product.upper.ToUInt64());
195       product = a.MultiplySigned(b);
196       MATCH((sx * sy) & maxUnsignedValue, product.lower.ToUInt64())
197       ("%s, x=0x%llx, y=0x%llx", desc, x, y);
198       MATCH(((sx * sy) >> BITS) & maxUnsignedValue, product.upper.ToUInt64())
199       ("%s, x=0x%llx, y=0x%llx", desc, x, y);
200       auto quot{a.DivideUnsigned(b)};
201       MATCH(y == 0, quot.divisionByZero)("%s, x=0x%llx, y=0x%llx", desc, x, y);
202       if (y == 0) {
203         MATCH(maxUnsignedValue, quot.quotient.ToUInt64())
204         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
205         MATCH(0, quot.remainder.ToUInt64())
206         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
207       } else {
208         MATCH(x / y, quot.quotient.ToUInt64())
209         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
210         MATCH(x % y, quot.remainder.ToUInt64())
211         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
212       }
213       quot = a.DivideSigned(b);
214       bool badCase{sx == mostNegativeSignedValue &&
215           ((sy == -1 && sx != sy) || (BITS == 1 && sx == sy))};
216       MATCH(y == 0, quot.divisionByZero)("%s, x=0x%llx, y=0x%llx", desc, x, y);
217       MATCH(badCase, quot.overflow)("%s, x=0x%llx, y=0x%llx", desc, x, y);
218       if (y == 0) {
219         if (sx >= 0) {
220           MATCH(maxPositiveSignedValue, quot.quotient.ToInt64())
221           ("%s, x=0x%llx, y=0x%llx", desc, x, y);
222         } else {
223           MATCH(mostNegativeSignedValue, quot.quotient.ToInt64())
224           ("%s, x=0x%llx, y=0x%llx", desc, x, y);
225         }
226         MATCH(0, quot.remainder.ToUInt64())
227         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
228       } else if (badCase) {
229         MATCH(x, quot.quotient.ToUInt64())
230         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
231         MATCH(0, quot.remainder.ToUInt64())
232         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
233       } else {
234         MATCH(sx / sy, quot.quotient.ToInt64())
235         ("%s, x=0x%llx %lld, y=0x%llx %lld; unsigned 0x%llx", desc, x, sx, y,
236             sy, quot.quotient.ToUInt64());
237         MATCH(sx - sy * (sx / sy), quot.remainder.ToInt64())
238         ("%s, x=0x%llx, y=0x%llx", desc, x, y);
239       }
240     }
241   }
242 }
243 
244 int main() {
245   TEST(Reverse(Ordering::Less) == Ordering::Greater);
246   TEST(Reverse(Ordering::Greater) == Ordering::Less);
247   TEST(Reverse(Ordering::Equal) == Ordering::Equal);
248   TEST(Integer<128>{123456789}.UnsignedDecimal() == "123456789");
249   TEST(Integer<128>{123456789}.SignedDecimal() == "123456789");
250   TEST(Integer<128>{-123456789}.SignedDecimal() == "-123456789");
251   std::uint64_t big{0x123456789abcdef};
252   TEST(Integer<128>{big}.Hexadecimal() == "123456789abcdef");
253   exhaustiveTesting<1>();
254   exhaustiveTesting<2>();
255   exhaustiveTesting<7>();
256   exhaustiveTesting<8>();
257   exhaustiveTesting<9>();
258   exhaustiveTesting<9, Integer<9, true, 1>>();
259   exhaustiveTesting<9, Integer<9, true, 1, std::uint8_t, std::uint16_t>>();
260   exhaustiveTesting<9, Integer<9, true, 2>>();
261   exhaustiveTesting<9, Integer<9, true, 2, std::uint8_t, std::uint16_t>>();
262   exhaustiveTesting<9, Integer<9, true, 8, std::uint8_t, std::uint16_t>>();
263   exhaustiveTesting<9, Integer<9, false, 8, std::uint8_t, std::uint16_t>>();
264   return testing::Complete();
265 }
266