1//===- unittests/Support/MathExtrasTest.cpp - math utils tests ------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/Support/MathExtras.h"
10#include "gtest/gtest.h"
11
12using namespace llvm;
13
14namespace {
15
16TEST(MathExtras, onesMask) {
17 EXPECT_EQ(0U, maskLeadingOnes<uint8_t>(0));
18 EXPECT_EQ(0U, maskTrailingOnes<uint8_t>(0));
19 EXPECT_EQ(0U, maskLeadingOnes<uint16_t>(0));
20 EXPECT_EQ(0U, maskTrailingOnes<uint16_t>(0));
21 EXPECT_EQ(0U, maskLeadingOnes<uint32_t>(0));
22 EXPECT_EQ(0U, maskTrailingOnes<uint32_t>(0));
23 EXPECT_EQ(0U, maskLeadingOnes<uint64_t>(0));
24 EXPECT_EQ(0U, maskTrailingOnes<uint64_t>(0));
25
26 EXPECT_EQ(0x00000003U, maskTrailingOnes<uint32_t>(2U));
27 EXPECT_EQ(0xC0000000U, maskLeadingOnes<uint32_t>(2U));
28
29 EXPECT_EQ(0x000007FFU, maskTrailingOnes<uint32_t>(11U));
30 EXPECT_EQ(0xFFE00000U, maskLeadingOnes<uint32_t>(11U));
31
32 EXPECT_EQ(0xFFFFFFFFU, maskTrailingOnes<uint32_t>(32U));
33 EXPECT_EQ(0xFFFFFFFFU, maskLeadingOnes<uint32_t>(32U));
34 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(64U));
35 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskLeadingOnes<uint64_t>(64U));
36
37 EXPECT_EQ(0x0000FFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(48U));
38 EXPECT_EQ(0xFFFFFFFFFFFF0000ULL, maskLeadingOnes<uint64_t>(48U));
39}
40
41TEST(MathExtras, isIntN) {
42 EXPECT_TRUE(isIntN(16, 32767));
43 EXPECT_FALSE(isIntN(16, 32768));
44 EXPECT_TRUE(isIntN(0, 0));
45 EXPECT_FALSE(isIntN(0, 1));
46 EXPECT_FALSE(isIntN(0, -1));
47}
48
49TEST(MathExtras, isUIntN) {
50 EXPECT_TRUE(isUIntN(16, 65535));
51 EXPECT_FALSE(isUIntN(16, 65536));
52 EXPECT_TRUE(isUIntN(1, 0));
53 EXPECT_TRUE(isUIntN(6, 63));
54 EXPECT_TRUE(isUIntN(0, 0));
55 EXPECT_FALSE(isUIntN(0, 1));
56}
57
58TEST(MathExtras, maxIntN) {
59 EXPECT_EQ(32767, maxIntN(16));
60 EXPECT_EQ(2147483647, maxIntN(32));
61 EXPECT_EQ(std::numeric_limits<int32_t>::max(), maxIntN(32));
62 EXPECT_EQ(std::numeric_limits<int64_t>::max(), maxIntN(64));
63 EXPECT_EQ(0, maxIntN(0));
64}
65
66TEST(MathExtras, minIntN) {
67 EXPECT_EQ(-32768LL, minIntN(16));
68 EXPECT_EQ(-64LL, minIntN(7));
69 EXPECT_EQ(std::numeric_limits<int32_t>::min(), minIntN(32));
70 EXPECT_EQ(std::numeric_limits<int64_t>::min(), minIntN(64));
71 EXPECT_EQ(0, minIntN(0));
72}
73
74TEST(MathExtras, maxUIntN) {
75 EXPECT_EQ(0xffffULL, maxUIntN(16));
76 EXPECT_EQ(0xffffffffULL, maxUIntN(32));
77 EXPECT_EQ(0xffffffffffffffffULL, maxUIntN(64));
78 EXPECT_EQ(1ULL, maxUIntN(1));
79 EXPECT_EQ(0x0fULL, maxUIntN(4));
80 EXPECT_EQ(0ULL, maxUIntN(0));
81}
82
83TEST(MathExtras, reverseBits) {
84 uint8_t NZ8 = 42;
85 uint16_t NZ16 = 42;
86 uint32_t NZ32 = 42;
87 uint64_t NZ64 = 42;
88 EXPECT_EQ(0x54ULL, reverseBits(NZ8));
89 EXPECT_EQ(0x5400ULL, reverseBits(NZ16));
90 EXPECT_EQ(0x54000000ULL, reverseBits(NZ32));
91 EXPECT_EQ(0x5400000000000000ULL, reverseBits(NZ64));
92}
93
94TEST(MathExtras, isShiftedMask_32) {
95 EXPECT_FALSE(isShiftedMask_32(0x01010101));
96 EXPECT_TRUE(isShiftedMask_32(0xf0000000));
97 EXPECT_TRUE(isShiftedMask_32(0xffff0000));
98 EXPECT_TRUE(isShiftedMask_32(0xff << 1));
99
100 unsigned MaskIdx, MaskLen;
101 EXPECT_FALSE(isShiftedMask_32(0x01010101, MaskIdx, MaskLen));
102 EXPECT_TRUE(isShiftedMask_32(0xf0000000, MaskIdx, MaskLen));
103 EXPECT_EQ(28, (int)MaskIdx);
104 EXPECT_EQ(4, (int)MaskLen);
105 EXPECT_TRUE(isShiftedMask_32(0xffff0000, MaskIdx, MaskLen));
106 EXPECT_EQ(16, (int)MaskIdx);
107 EXPECT_EQ(16, (int)MaskLen);
108 EXPECT_TRUE(isShiftedMask_32(0xff << 1, MaskIdx, MaskLen));
109 EXPECT_EQ(1, (int)MaskIdx);
110 EXPECT_EQ(8, (int)MaskLen);
111}
112
113TEST(MathExtras, isShiftedMask_64) {
114 EXPECT_FALSE(isShiftedMask_64(0x0101010101010101ull));
115 EXPECT_TRUE(isShiftedMask_64(0xf000000000000000ull));
116 EXPECT_TRUE(isShiftedMask_64(0xffff000000000000ull));
117 EXPECT_TRUE(isShiftedMask_64(0xffull << 55));
118
119 unsigned MaskIdx, MaskLen;
120 EXPECT_FALSE(isShiftedMask_64(0x0101010101010101ull, MaskIdx, MaskLen));
121 EXPECT_TRUE(isShiftedMask_64(0xf000000000000000ull, MaskIdx, MaskLen));
122 EXPECT_EQ(60, (int)MaskIdx);
123 EXPECT_EQ(4, (int)MaskLen);
124 EXPECT_TRUE(isShiftedMask_64(0xffff000000000000ull, MaskIdx, MaskLen));
125 EXPECT_EQ(48, (int)MaskIdx);
126 EXPECT_EQ(16, (int)MaskLen);
127 EXPECT_TRUE(isShiftedMask_64(0xffull << 55, MaskIdx, MaskLen));
128 EXPECT_EQ(55, (int)MaskIdx);
129 EXPECT_EQ(8, (int)MaskLen);
130}
131
132TEST(MathExtras, isPowerOf2_32) {
133 EXPECT_FALSE(isPowerOf2_32(0));
134 EXPECT_TRUE(isPowerOf2_32(1 << 6));
135 EXPECT_TRUE(isPowerOf2_32(1 << 12));
136 EXPECT_FALSE(isPowerOf2_32((1 << 19) + 3));
137 EXPECT_FALSE(isPowerOf2_32(0xABCDEF0));
138}
139
140TEST(MathExtras, isPowerOf2_64) {
141 EXPECT_FALSE(isPowerOf2_64(0));
142 EXPECT_TRUE(isPowerOf2_64(1LL << 46));
143 EXPECT_TRUE(isPowerOf2_64(1LL << 12));
144 EXPECT_FALSE(isPowerOf2_64((1LL << 53) + 3));
145 EXPECT_FALSE(isPowerOf2_64(0xABCDEF0ABCDEF0LL));
146}
147
148TEST(MathExtras, PowerOf2Ceil) {
149 EXPECT_EQ(0U, PowerOf2Ceil(0U));
150 EXPECT_EQ(8U, PowerOf2Ceil(8U));
151 EXPECT_EQ(8U, PowerOf2Ceil(7U));
152}
153
154TEST(MathExtras, CTLog2) {
155 EXPECT_EQ(CTLog2<1ULL << 0>(), 0U);
156 EXPECT_EQ(CTLog2<1ULL << 1>(), 1U);
157 EXPECT_EQ(CTLog2<1ULL << 2>(), 2U);
158 EXPECT_EQ(CTLog2<1ULL << 3>(), 3U);
159 EXPECT_EQ(CTLog2<1ULL << 4>(), 4U);
160 EXPECT_EQ(CTLog2<1ULL << 5>(), 5U);
161 EXPECT_EQ(CTLog2<1ULL << 6>(), 6U);
162 EXPECT_EQ(CTLog2<1ULL << 7>(), 7U);
163 EXPECT_EQ(CTLog2<1ULL << 8>(), 8U);
164 EXPECT_EQ(CTLog2<1ULL << 9>(), 9U);
165 EXPECT_EQ(CTLog2<1ULL << 10>(), 10U);
166 EXPECT_EQ(CTLog2<1ULL << 11>(), 11U);
167 EXPECT_EQ(CTLog2<1ULL << 12>(), 12U);
168 EXPECT_EQ(CTLog2<1ULL << 13>(), 13U);
169 EXPECT_EQ(CTLog2<1ULL << 14>(), 14U);
170 EXPECT_EQ(CTLog2<1ULL << 15>(), 15U);
171}
172
173TEST(MathExtras, MinAlign) {
174 EXPECT_EQ(1u, MinAlign(2, 3));
175 EXPECT_EQ(2u, MinAlign(2, 4));
176 EXPECT_EQ(1u, MinAlign(17, 64));
177 EXPECT_EQ(256u, MinAlign(256, 512));
178}
179
180TEST(MathExtras, NextPowerOf2) {
181 EXPECT_EQ(4u, NextPowerOf2(3));
182 EXPECT_EQ(16u, NextPowerOf2(15));
183 EXPECT_EQ(256u, NextPowerOf2(128));
184}
185
186TEST(MathExtras, alignTo) {
187 EXPECT_EQ(8u, alignTo(5, 8));
188 EXPECT_EQ(24u, alignTo(17, 8));
189 EXPECT_EQ(0u, alignTo(~0LL, 8));
190
191 EXPECT_EQ(7u, alignTo(5, 8, 7));
192 EXPECT_EQ(17u, alignTo(17, 8, 1));
193 EXPECT_EQ(3u, alignTo(~0LL, 8, 3));
194 EXPECT_EQ(552u, alignTo(321, 255, 42));
195}
196
197template <typename T> void SaturatingAddTestHelper() {
198 const T Max = std::numeric_limits<T>::max();
199 bool ResultOverflowed;
200
201 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2)));
202 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), &ResultOverflowed));
203 EXPECT_FALSE(ResultOverflowed);
204
205 EXPECT_EQ(Max, SaturatingAdd(Max, T(1)));
206 EXPECT_EQ(Max, SaturatingAdd(Max, T(1), &ResultOverflowed));
207 EXPECT_TRUE(ResultOverflowed);
208
209 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1)));
210 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), &ResultOverflowed));
211 EXPECT_FALSE(ResultOverflowed);
212
213 EXPECT_EQ(Max, SaturatingAdd(T(1), Max));
214 EXPECT_EQ(Max, SaturatingAdd(T(1), Max, &ResultOverflowed));
215 EXPECT_TRUE(ResultOverflowed);
216
217 EXPECT_EQ(Max, SaturatingAdd(Max, Max));
218 EXPECT_EQ(Max, SaturatingAdd(Max, Max, &ResultOverflowed));
219 EXPECT_TRUE(ResultOverflowed);
220
221 EXPECT_EQ(T(6), SaturatingAdd(T(1), T(2), T(3)));
222 EXPECT_EQ(T(6), SaturatingAdd(T(1), T(2), T(3), &ResultOverflowed));
223 EXPECT_FALSE(ResultOverflowed);
224
225 EXPECT_EQ(T(10), SaturatingAdd(T(1), T(2), T(3), T(4)));
226 EXPECT_EQ(T(10), SaturatingAdd(T(1), T(2), T(3), T(4), &ResultOverflowed));
227 EXPECT_FALSE(ResultOverflowed);
228
229 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(0)));
230 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(0), &ResultOverflowed));
231 EXPECT_FALSE(ResultOverflowed);
232
233 EXPECT_EQ(Max, SaturatingAdd(T(0), T(0), Max));
234 EXPECT_EQ(Max, SaturatingAdd(T(0), T(0), Max, &ResultOverflowed));
235 EXPECT_FALSE(ResultOverflowed);
236
237 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(1)));
238 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(1), &ResultOverflowed));
239 EXPECT_TRUE(ResultOverflowed);
240
241 EXPECT_EQ(Max, SaturatingAdd(T(0), T(1), Max));
242 EXPECT_EQ(Max, SaturatingAdd(T(0), T(1), Max, &ResultOverflowed));
243 EXPECT_TRUE(ResultOverflowed);
244
245 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 2), T(1)));
246 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 2), T(1), &ResultOverflowed));
247 EXPECT_FALSE(ResultOverflowed);
248
249 EXPECT_EQ(Max, SaturatingAdd(T(1), T(1), T(Max - 2)));
250 EXPECT_EQ(Max, SaturatingAdd(T(1), T(1), T(Max - 2), &ResultOverflowed));
251 EXPECT_FALSE(ResultOverflowed);
252
253 EXPECT_EQ(Max, SaturatingAdd(Max, Max, Max));
254 EXPECT_EQ(Max, SaturatingAdd(Max, Max, Max, &ResultOverflowed));
255 EXPECT_TRUE(ResultOverflowed);
256}
257
258TEST(MathExtras, SaturatingAdd) {
259 SaturatingAddTestHelper<uint8_t>();
260 SaturatingAddTestHelper<uint16_t>();
261 SaturatingAddTestHelper<uint32_t>();
262 SaturatingAddTestHelper<uint64_t>();
263}
264
265template<typename T>
266void SaturatingMultiplyTestHelper()
267{
268 const T Max = std::numeric_limits<T>::max();
269 bool ResultOverflowed;
270
271 // Test basic multiplication.
272 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3)));
273 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), &ResultOverflowed));
274 EXPECT_FALSE(ResultOverflowed);
275
276 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2)));
277 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), &ResultOverflowed));
278 EXPECT_FALSE(ResultOverflowed);
279
280 // Test multiplication by zero.
281 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0)));
282 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), &ResultOverflowed));
283 EXPECT_FALSE(ResultOverflowed);
284
285 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0)));
286 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), &ResultOverflowed));
287 EXPECT_FALSE(ResultOverflowed);
288
289 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1)));
290 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), &ResultOverflowed));
291 EXPECT_FALSE(ResultOverflowed);
292
293 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0)));
294 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), &ResultOverflowed));
295 EXPECT_FALSE(ResultOverflowed);
296
297 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max));
298 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, &ResultOverflowed));
299 EXPECT_FALSE(ResultOverflowed);
300
301 // Test multiplication by maximum value.
302 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2)));
303 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), &ResultOverflowed));
304 EXPECT_TRUE(ResultOverflowed);
305
306 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max));
307 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, &ResultOverflowed));
308 EXPECT_TRUE(ResultOverflowed);
309
310 EXPECT_EQ(Max, SaturatingMultiply(Max, Max));
311 EXPECT_EQ(Max, SaturatingMultiply(Max, Max, &ResultOverflowed));
312 EXPECT_TRUE(ResultOverflowed);
313
314 // Test interesting boundary conditions for algorithm -
315 // ((1 << A) - 1) * ((1 << B) + K) for K in [-1, 0, 1]
316 // and A + B == std::numeric_limits<T>::digits.
317 // We expect overflow iff A > B and K = 1.
318 const int Digits = std::numeric_limits<T>::digits;
319 for (int A = 1, B = Digits - 1; B >= 1; ++A, --B) {
320 for (int K = -1; K <= 1; ++K) {
321 T X = (T(1) << A) - T(1);
322 T Y = (T(1) << B) + K;
323 bool OverflowExpected = A > B && K == 1;
324
325 if(OverflowExpected) {
326 EXPECT_EQ(Max, SaturatingMultiply(X, Y));
327 EXPECT_EQ(Max, SaturatingMultiply(X, Y, &ResultOverflowed));
328 EXPECT_TRUE(ResultOverflowed);
329 } else {
330 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y));
331 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, &ResultOverflowed));
332 EXPECT_FALSE(ResultOverflowed);
333 }
334 }
335 }
336}
337
338TEST(MathExtras, SaturatingMultiply) {
339 SaturatingMultiplyTestHelper<uint8_t>();
340 SaturatingMultiplyTestHelper<uint16_t>();
341 SaturatingMultiplyTestHelper<uint32_t>();
342 SaturatingMultiplyTestHelper<uint64_t>();
343}
344
345template<typename T>
346void SaturatingMultiplyAddTestHelper()
347{
348 const T Max = std::numeric_limits<T>::max();
349 bool ResultOverflowed;
350
351 // Test basic multiply-add.
352 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10)));
353 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10), &ResultOverflowed));
354 EXPECT_FALSE(ResultOverflowed);
355
356 // Test multiply overflows, add doesn't overflow
357 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(0), &ResultOverflowed));
358 EXPECT_TRUE(ResultOverflowed);
359
360 // Test multiply doesn't overflow, add overflows
361 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed));
362 EXPECT_TRUE(ResultOverflowed);
363
364 // Test multiply-add with Max as operand
365 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed));
366 EXPECT_TRUE(ResultOverflowed);
367
368 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), Max, T(1), &ResultOverflowed));
369 EXPECT_TRUE(ResultOverflowed);
370
371 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(1), &ResultOverflowed));
372 EXPECT_TRUE(ResultOverflowed);
373
374 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, Max, &ResultOverflowed));
375 EXPECT_TRUE(ResultOverflowed);
376
377 // Test multiply-add with 0 as operand
378 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(1), T(0), &ResultOverflowed));
379 EXPECT_FALSE(ResultOverflowed);
380
381 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(0), T(1), &ResultOverflowed));
382 EXPECT_FALSE(ResultOverflowed);
383
384 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(0), T(0), T(1), &ResultOverflowed));
385 EXPECT_FALSE(ResultOverflowed);
386
387 EXPECT_EQ(T(0), SaturatingMultiplyAdd(T(0), T(0), T(0), &ResultOverflowed));
388 EXPECT_FALSE(ResultOverflowed);
389
390}
391
392TEST(MathExtras, SaturatingMultiplyAdd) {
393 SaturatingMultiplyAddTestHelper<uint8_t>();
394 SaturatingMultiplyAddTestHelper<uint16_t>();
395 SaturatingMultiplyAddTestHelper<uint32_t>();
396 SaturatingMultiplyAddTestHelper<uint64_t>();
397}
398
399TEST(MathExtras, IsShiftedUInt) {
400 EXPECT_TRUE((isShiftedUInt<1, 0>(0)));
401 EXPECT_TRUE((isShiftedUInt<1, 0>(1)));
402 EXPECT_FALSE((isShiftedUInt<1, 0>(2)));
403 EXPECT_FALSE((isShiftedUInt<1, 0>(3)));
404 EXPECT_FALSE((isShiftedUInt<1, 0>(0x8000000000000000)));
405 EXPECT_TRUE((isShiftedUInt<1, 63>(0x8000000000000000)));
406 EXPECT_TRUE((isShiftedUInt<2, 62>(0xC000000000000000)));
407 EXPECT_FALSE((isShiftedUInt<2, 62>(0xE000000000000000)));
408
409 // 0x201 is ten bits long and has a 1 in the MSB and LSB.
410 EXPECT_TRUE((isShiftedUInt<10, 5>(uint64_t(0x201) << 5)));
411 EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 4)));
412 EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 6)));
413}
414
415TEST(MathExtras, IsShiftedInt) {
416 EXPECT_TRUE((isShiftedInt<1, 0>(0)));
417 EXPECT_TRUE((isShiftedInt<1, 0>(-1)));
418 EXPECT_FALSE((isShiftedInt<1, 0>(2)));
419 EXPECT_FALSE((isShiftedInt<1, 0>(3)));
420 EXPECT_FALSE((isShiftedInt<1, 0>(0x8000000000000000)));
421 EXPECT_TRUE((isShiftedInt<1, 63>(0x8000000000000000)));
422 EXPECT_TRUE((isShiftedInt<2, 62>(0xC000000000000000)));
423 EXPECT_FALSE((isShiftedInt<2, 62>(0xE000000000000000)));
424
425 // 0x201 is ten bits long and has a 1 in the MSB and LSB.
426 EXPECT_TRUE((isShiftedInt<11, 5>(int64_t(0x201) << 5)));
427 EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 3)));
428 EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 6)));
429 EXPECT_TRUE((isShiftedInt<11, 5>(-(int64_t(0x201) << 5))));
430 EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 3))));
431 EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 6))));
432
433 EXPECT_TRUE((isShiftedInt<6, 10>(-(int64_t(1) << 15))));
434 EXPECT_FALSE((isShiftedInt<6, 10>(int64_t(1) << 15)));
435}
436
437template <typename T>
438class OverflowTest : public ::testing::Test { };
439
440using OverflowTestTypes = ::testing::Types<signed char, short, int, long,
441 long long>;
442
443TYPED_TEST_SUITE(OverflowTest, OverflowTestTypes, );
444
445TYPED_TEST(OverflowTest, AddNoOverflow) {
446 TypeParam Result;
447 EXPECT_FALSE(AddOverflow<TypeParam>(1, 2, Result));
448 EXPECT_EQ(Result, TypeParam(3));
449}
450
451TYPED_TEST(OverflowTest, AddOverflowToNegative) {
452 TypeParam Result;
453 auto MaxValue = std::numeric_limits<TypeParam>::max();
454 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, MaxValue, Result));
455 EXPECT_EQ(Result, TypeParam(-2));
456}
457
458TYPED_TEST(OverflowTest, AddOverflowToMin) {
459 TypeParam Result;
460 auto MaxValue = std::numeric_limits<TypeParam>::max();
461 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, TypeParam(1), Result));
462 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::min());
463}
464
465TYPED_TEST(OverflowTest, AddOverflowToZero) {
466 TypeParam Result;
467 auto MinValue = std::numeric_limits<TypeParam>::min();
468 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, MinValue, Result));
469 EXPECT_EQ(Result, TypeParam(0));
470}
471
472TYPED_TEST(OverflowTest, AddOverflowToMax) {
473 TypeParam Result;
474 auto MinValue = std::numeric_limits<TypeParam>::min();
475 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, TypeParam(-1), Result));
476 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::max());
477}
478
479TYPED_TEST(OverflowTest, SubNoOverflow) {
480 TypeParam Result;
481 EXPECT_FALSE(SubOverflow<TypeParam>(1, 2, Result));
482 EXPECT_EQ(Result, TypeParam(-1));
483}
484
485TYPED_TEST(OverflowTest, SubOverflowToMax) {
486 TypeParam Result;
487 auto MinValue = std::numeric_limits<TypeParam>::min();
488 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result));
489 EXPECT_EQ(Result, MinValue);
490}
491
492TYPED_TEST(OverflowTest, SubOverflowToMin) {
493 TypeParam Result;
494 auto MinValue = std::numeric_limits<TypeParam>::min();
495 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result));
496 EXPECT_EQ(Result, MinValue);
497}
498
499TYPED_TEST(OverflowTest, SubOverflowToNegative) {
500 TypeParam Result;
501 auto MaxValue = std::numeric_limits<TypeParam>::max();
502 auto MinValue = std::numeric_limits<TypeParam>::min();
503 EXPECT_TRUE(SubOverflow<TypeParam>(MaxValue, MinValue, Result));
504 EXPECT_EQ(Result, TypeParam(-1));
505}
506
507TYPED_TEST(OverflowTest, SubOverflowToPositive) {
508 TypeParam Result;
509 auto MaxValue = std::numeric_limits<TypeParam>::max();
510 auto MinValue = std::numeric_limits<TypeParam>::min();
511 EXPECT_TRUE(SubOverflow<TypeParam>(MinValue, MaxValue, Result));
512 EXPECT_EQ(Result, TypeParam(1));
513}
514
515TYPED_TEST(OverflowTest, MulNoOverflow) {
516 TypeParam Result;
517 EXPECT_FALSE(MulOverflow<TypeParam>(1, 2, Result));
518 EXPECT_EQ(Result, 2);
519 EXPECT_FALSE(MulOverflow<TypeParam>(-1, 3, Result));
520 EXPECT_EQ(Result, -3);
521 EXPECT_FALSE(MulOverflow<TypeParam>(4, -2, Result));
522 EXPECT_EQ(Result, -8);
523 EXPECT_FALSE(MulOverflow<TypeParam>(-6, -5, Result));
524 EXPECT_EQ(Result, 30);
525}
526
527TYPED_TEST(OverflowTest, MulNoOverflowToMax) {
528 TypeParam Result;
529 auto MaxValue = std::numeric_limits<TypeParam>::max();
530 auto MinValue = std::numeric_limits<TypeParam>::min();
531 EXPECT_FALSE(MulOverflow<TypeParam>(MinValue + 1, -1, Result));
532 EXPECT_EQ(Result, MaxValue);
533}
534
535TYPED_TEST(OverflowTest, MulOverflowToMin) {
536 TypeParam Result;
537 auto MinValue = std::numeric_limits<TypeParam>::min();
538 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, -1, Result));
539 EXPECT_EQ(Result, MinValue);
540}
541
542TYPED_TEST(OverflowTest, MulOverflowMax) {
543 TypeParam Result;
544 auto MinValue = std::numeric_limits<TypeParam>::min();
545 auto MaxValue = std::numeric_limits<TypeParam>::max();
546 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, MinValue, Result));
547 EXPECT_EQ(Result, 0);
548 EXPECT_TRUE(MulOverflow<TypeParam>(MaxValue, MaxValue, Result));
549 EXPECT_EQ(Result, 1);
550}
551
552TYPED_TEST(OverflowTest, MulResultZero) {
553 TypeParam Result;
554 EXPECT_FALSE(MulOverflow<TypeParam>(4, 0, Result));
555 EXPECT_EQ(Result, TypeParam(0));
556 EXPECT_FALSE(MulOverflow<TypeParam>(-5, 0, Result));
557 EXPECT_EQ(Result, TypeParam(0));
558 EXPECT_FALSE(MulOverflow<TypeParam>(0, 5, Result));
559 EXPECT_EQ(Result, TypeParam(0));
560 EXPECT_FALSE(MulOverflow<TypeParam>(0, -5, Result));
561 EXPECT_EQ(Result, TypeParam(0));
562}
563
564} // namespace
565

source code of llvm/unittests/Support/MathExtrasTest.cpp