1 //===- llvm/unittest/ADT/APInt.cpp - APInt unit 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/ADT/APInt.h" 10 #include "llvm/ADT/ArrayRef.h" 11 #include "llvm/ADT/DenseMap.h" 12 #include "llvm/ADT/SmallString.h" 13 #include "llvm/ADT/Twine.h" 14 #include "llvm/Support/Alignment.h" 15 #include "gtest/gtest.h" 16 #include <array> 17 #include <climits> 18 #include <limits> 19 #include <optional> 20 21 using namespace llvm; 22 23 namespace { 24 25 TEST(APIntTest, ValueInit) { 26 APInt Zero = APInt(); 27 EXPECT_TRUE(!Zero); 28 EXPECT_TRUE(!Zero.zext(64)); 29 EXPECT_TRUE(!Zero.sext(64)); 30 } 31 32 // Test that 0^5 == 0 33 TEST(APIntTest, PowZeroTo5) { 34 APInt Zero = APInt::getZero(32); 35 EXPECT_TRUE(!Zero); 36 APInt ZeroTo5 = APIntOps::pow(Zero, 5); 37 EXPECT_TRUE(!ZeroTo5); 38 } 39 40 // Test that 1^16 == 1 41 TEST(APIntTest, PowOneTo16) { 42 APInt One(32, 1); 43 APInt OneTo16 = APIntOps::pow(One, 16); 44 EXPECT_EQ(One, OneTo16); 45 } 46 47 // Test that 2^10 == 1024 48 TEST(APIntTest, PowerTwoTo10) { 49 APInt Two(32, 2); 50 APInt TwoTo20 = APIntOps::pow(Two, 10); 51 APInt V_1024(32, 1024); 52 EXPECT_EQ(TwoTo20, V_1024); 53 } 54 55 // Test that 3^3 == 27 56 TEST(APIntTest, PowerThreeTo3) { 57 APInt Three(32, 3); 58 APInt ThreeTo3 = APIntOps::pow(Three, 3); 59 APInt V_27(32, 27); 60 EXPECT_EQ(ThreeTo3, V_27); 61 } 62 63 // Test that SignedMaxValue^3 == SignedMaxValue 64 TEST(APIntTest, PowerSignedMaxValue) { 65 APInt SignedMaxValue = APInt::getSignedMaxValue(32); 66 APInt MaxTo3 = APIntOps::pow(SignedMaxValue, 3); 67 EXPECT_EQ(MaxTo3, SignedMaxValue); 68 } 69 70 // Test that MaxValue^3 == MaxValue 71 TEST(APIntTest, PowerMaxValue) { 72 APInt MaxValue = APInt::getMaxValue(32); 73 APInt MaxTo3 = APIntOps::pow(MaxValue, 3); 74 EXPECT_EQ(MaxValue, MaxTo3); 75 } 76 77 // Test that SignedMinValue^3 == 0 78 TEST(APIntTest, PowerSignedMinValueTo3) { 79 APInt SignedMinValue = APInt::getSignedMinValue(32); 80 APInt MinTo3 = APIntOps::pow(SignedMinValue, 3); 81 EXPECT_TRUE(MinTo3.isZero()); 82 } 83 84 // Test that SignedMinValue^1 == SignedMinValue 85 TEST(APIntTest, PowerSignedMinValueTo1) { 86 APInt SignedMinValue = APInt::getSignedMinValue(32); 87 APInt MinTo1 = APIntOps::pow(SignedMinValue, 1); 88 EXPECT_EQ(SignedMinValue, MinTo1); 89 } 90 91 // Test that MaxValue^3 == MaxValue 92 TEST(APIntTest, ZeroToZero) { 93 APInt Zero = APInt::getZero(32); 94 APInt One(32, 1); 95 APInt ZeroToZero = APIntOps::pow(Zero, 0); 96 EXPECT_EQ(ZeroToZero, One); 97 } 98 99 // Test that APInt shift left works when bitwidth > 64 and shiftamt == 0 100 TEST(APIntTest, ShiftLeftByZero) { 101 APInt One = APInt::getZero(65) + 1; 102 APInt Shl = One.shl(0); 103 EXPECT_TRUE(Shl[0]); 104 EXPECT_FALSE(Shl[1]); 105 } 106 107 TEST(APIntTest, i64_ArithmeticRightShiftNegative) { 108 const APInt neg_one(64, static_cast<uint64_t>(-1), true); 109 EXPECT_EQ(neg_one, neg_one.ashr(7)); 110 } 111 112 TEST(APIntTest, i128_NegativeCount) { 113 APInt Minus3(128, static_cast<uint64_t>(-3), true); 114 EXPECT_EQ(126u, Minus3.countl_one()); 115 EXPECT_EQ(-3, Minus3.getSExtValue()); 116 117 APInt Minus1(128, static_cast<uint64_t>(-1), true); 118 EXPECT_EQ(0u, Minus1.countl_zero()); 119 EXPECT_EQ(128u, Minus1.countl_one()); 120 EXPECT_EQ(128u, Minus1.getActiveBits()); 121 EXPECT_EQ(0u, Minus1.countr_zero()); 122 EXPECT_EQ(128u, Minus1.countr_one()); 123 EXPECT_EQ(128u, Minus1.popcount()); 124 EXPECT_EQ(-1, Minus1.getSExtValue()); 125 } 126 127 TEST(APIntTest, i33_Count) { 128 APInt i33minus2(33, static_cast<uint64_t>(-2), true); 129 EXPECT_EQ(0u, i33minus2.countl_zero()); 130 EXPECT_EQ(32u, i33minus2.countl_one()); 131 EXPECT_EQ(33u, i33minus2.getActiveBits()); 132 EXPECT_EQ(1u, i33minus2.countr_zero()); 133 EXPECT_EQ(32u, i33minus2.popcount()); 134 EXPECT_EQ(-2, i33minus2.getSExtValue()); 135 EXPECT_EQ(((uint64_t)-2)&((1ull<<33) -1), i33minus2.getZExtValue()); 136 } 137 138 TEST(APIntTest, i61_Count) { 139 APInt i61(61, 1 << 15); 140 EXPECT_EQ(45u, i61.countl_zero()); 141 EXPECT_EQ(0u, i61.countl_one()); 142 EXPECT_EQ(16u, i61.getActiveBits()); 143 EXPECT_EQ(15u, i61.countr_zero()); 144 EXPECT_EQ(1u, i61.popcount()); 145 EXPECT_EQ(static_cast<int64_t>(1 << 15), i61.getSExtValue()); 146 EXPECT_EQ(static_cast<uint64_t>(1 << 15), i61.getZExtValue()); 147 148 i61.setBits(8, 19); 149 EXPECT_EQ(42u, i61.countl_zero()); 150 EXPECT_EQ(0u, i61.countl_one()); 151 EXPECT_EQ(19u, i61.getActiveBits()); 152 EXPECT_EQ(8u, i61.countr_zero()); 153 EXPECT_EQ(11u, i61.popcount()); 154 EXPECT_EQ(static_cast<int64_t>((1 << 19) - (1 << 8)), i61.getSExtValue()); 155 EXPECT_EQ(static_cast<uint64_t>((1 << 19) - (1 << 8)), i61.getZExtValue()); 156 } 157 158 TEST(APIntTest, i65_Count) { 159 APInt i65(65, 0, true); 160 EXPECT_EQ(65u, i65.countl_zero()); 161 EXPECT_EQ(0u, i65.countl_one()); 162 EXPECT_EQ(0u, i65.getActiveBits()); 163 EXPECT_EQ(1u, i65.getActiveWords()); 164 EXPECT_EQ(65u, i65.countr_zero()); 165 EXPECT_EQ(0u, i65.popcount()); 166 167 APInt i65minus(65, 0, true); 168 i65minus.setBit(64); 169 EXPECT_EQ(0u, i65minus.countl_zero()); 170 EXPECT_EQ(1u, i65minus.countl_one()); 171 EXPECT_EQ(65u, i65minus.getActiveBits()); 172 EXPECT_EQ(64u, i65minus.countr_zero()); 173 EXPECT_EQ(1u, i65minus.popcount()); 174 } 175 176 TEST(APIntTest, i128_PositiveCount) { 177 APInt u128max = APInt::getAllOnes(128); 178 EXPECT_EQ(128u, u128max.countl_one()); 179 EXPECT_EQ(0u, u128max.countl_zero()); 180 EXPECT_EQ(128u, u128max.getActiveBits()); 181 EXPECT_EQ(0u, u128max.countr_zero()); 182 EXPECT_EQ(128u, u128max.countr_one()); 183 EXPECT_EQ(128u, u128max.popcount()); 184 185 APInt u64max(128, static_cast<uint64_t>(-1), false); 186 EXPECT_EQ(64u, u64max.countl_zero()); 187 EXPECT_EQ(0u, u64max.countl_one()); 188 EXPECT_EQ(64u, u64max.getActiveBits()); 189 EXPECT_EQ(0u, u64max.countr_zero()); 190 EXPECT_EQ(64u, u64max.countr_one()); 191 EXPECT_EQ(64u, u64max.popcount()); 192 EXPECT_EQ((uint64_t)~0ull, u64max.getZExtValue()); 193 194 APInt zero(128, 0, true); 195 EXPECT_EQ(128u, zero.countl_zero()); 196 EXPECT_EQ(0u, zero.countl_one()); 197 EXPECT_EQ(0u, zero.getActiveBits()); 198 EXPECT_EQ(128u, zero.countr_zero()); 199 EXPECT_EQ(0u, zero.countr_one()); 200 EXPECT_EQ(0u, zero.popcount()); 201 EXPECT_EQ(0u, zero.getSExtValue()); 202 EXPECT_EQ(0u, zero.getZExtValue()); 203 204 APInt one(128, 1, true); 205 EXPECT_EQ(127u, one.countl_zero()); 206 EXPECT_EQ(0u, one.countl_one()); 207 EXPECT_EQ(1u, one.getActiveBits()); 208 EXPECT_EQ(0u, one.countr_zero()); 209 EXPECT_EQ(1u, one.countr_one()); 210 EXPECT_EQ(1u, one.popcount()); 211 EXPECT_EQ(1, one.getSExtValue()); 212 EXPECT_EQ(1u, one.getZExtValue()); 213 214 APInt s128(128, 2, true); 215 EXPECT_EQ(126u, s128.countl_zero()); 216 EXPECT_EQ(0u, s128.countl_one()); 217 EXPECT_EQ(2u, s128.getActiveBits()); 218 EXPECT_EQ(1u, s128.countr_zero()); 219 EXPECT_EQ(0u, s128.countr_one()); 220 EXPECT_EQ(1u, s128.popcount()); 221 EXPECT_EQ(2, s128.getSExtValue()); 222 EXPECT_EQ(2u, s128.getZExtValue()); 223 224 // NOP Test 225 s128.setBits(42, 42); 226 EXPECT_EQ(126u, s128.countl_zero()); 227 EXPECT_EQ(0u, s128.countl_one()); 228 EXPECT_EQ(2u, s128.getActiveBits()); 229 EXPECT_EQ(1u, s128.countr_zero()); 230 EXPECT_EQ(0u, s128.countr_one()); 231 EXPECT_EQ(1u, s128.popcount()); 232 EXPECT_EQ(2, s128.getSExtValue()); 233 EXPECT_EQ(2u, s128.getZExtValue()); 234 235 s128.setBits(3, 32); 236 EXPECT_EQ(96u, s128.countl_zero()); 237 EXPECT_EQ(0u, s128.countl_one()); 238 EXPECT_EQ(32u, s128.getActiveBits()); 239 EXPECT_EQ(33u, s128.getSignificantBits()); 240 EXPECT_EQ(1u, s128.countr_zero()); 241 EXPECT_EQ(0u, s128.countr_one()); 242 EXPECT_EQ(30u, s128.popcount()); 243 EXPECT_EQ(static_cast<uint32_t>((~0u << 3) | 2), s128.getZExtValue()); 244 245 s128.setBits(62, 128); 246 EXPECT_EQ(0u, s128.countl_zero()); 247 EXPECT_EQ(66u, s128.countl_one()); 248 EXPECT_EQ(128u, s128.getActiveBits()); 249 EXPECT_EQ(63u, s128.getSignificantBits()); 250 EXPECT_EQ(1u, s128.countr_zero()); 251 EXPECT_EQ(0u, s128.countr_one()); 252 EXPECT_EQ(96u, s128.popcount()); 253 EXPECT_EQ(static_cast<int64_t>((3ull << 62) | 254 static_cast<uint32_t>((~0u << 3) | 2)), 255 s128.getSExtValue()); 256 } 257 258 TEST(APIntTest, i256) { 259 APInt s256(256, 15, true); 260 EXPECT_EQ(252u, s256.countl_zero()); 261 EXPECT_EQ(0u, s256.countl_one()); 262 EXPECT_EQ(4u, s256.getActiveBits()); 263 EXPECT_EQ(0u, s256.countr_zero()); 264 EXPECT_EQ(4u, s256.countr_one()); 265 EXPECT_EQ(4u, s256.popcount()); 266 EXPECT_EQ(15, s256.getSExtValue()); 267 EXPECT_EQ(15u, s256.getZExtValue()); 268 269 s256.setBits(62, 66); 270 EXPECT_EQ(190u, s256.countl_zero()); 271 EXPECT_EQ(0u, s256.countl_one()); 272 EXPECT_EQ(66u, s256.getActiveBits()); 273 EXPECT_EQ(67u, s256.getSignificantBits()); 274 EXPECT_EQ(0u, s256.countr_zero()); 275 EXPECT_EQ(4u, s256.countr_one()); 276 EXPECT_EQ(8u, s256.popcount()); 277 278 s256.setBits(60, 256); 279 EXPECT_EQ(0u, s256.countl_zero()); 280 EXPECT_EQ(196u, s256.countl_one()); 281 EXPECT_EQ(256u, s256.getActiveBits()); 282 EXPECT_EQ(61u, s256.getSignificantBits()); 283 EXPECT_EQ(0u, s256.countr_zero()); 284 EXPECT_EQ(4u, s256.countr_one()); 285 EXPECT_EQ(200u, s256.popcount()); 286 EXPECT_EQ(static_cast<int64_t>((~0ull << 60) | 15), s256.getSExtValue()); 287 } 288 289 TEST(APIntTest, i1) { 290 const APInt neg_two(1, static_cast<uint64_t>(-2), true, 291 /*implicitTrunc=*/true); 292 const APInt neg_one(1, static_cast<uint64_t>(-1), true); 293 const APInt zero(1, 0); 294 const APInt one(1, 1); 295 const APInt two(1, 2, false, /*implicitTrunc=*/true); 296 297 EXPECT_EQ(0, neg_two.getSExtValue()); 298 EXPECT_EQ(-1, neg_one.getSExtValue()); 299 EXPECT_EQ(1u, neg_one.getZExtValue()); 300 EXPECT_EQ(0u, zero.getZExtValue()); 301 EXPECT_EQ(-1, one.getSExtValue()); 302 EXPECT_EQ(1u, one.getZExtValue()); 303 EXPECT_EQ(0u, two.getZExtValue()); 304 EXPECT_EQ(0, two.getSExtValue()); 305 306 // Basic equalities for 1-bit values. 307 EXPECT_EQ(zero, two); 308 EXPECT_EQ(zero, neg_two); 309 EXPECT_EQ(one, neg_one); 310 EXPECT_EQ(two, neg_two); 311 312 // Min/max signed values. 313 EXPECT_TRUE(zero.isMaxSignedValue()); 314 EXPECT_FALSE(one.isMaxSignedValue()); 315 EXPECT_FALSE(zero.isMinSignedValue()); 316 EXPECT_TRUE(one.isMinSignedValue()); 317 318 // Additions. 319 EXPECT_EQ(two, one + one); 320 EXPECT_EQ(zero, neg_one + one); 321 EXPECT_EQ(neg_two, neg_one + neg_one); 322 323 // Subtractions. 324 EXPECT_EQ(neg_two, neg_one - one); 325 EXPECT_EQ(two, one - neg_one); 326 EXPECT_EQ(zero, one - one); 327 328 // And 329 EXPECT_EQ(zero, zero & zero); 330 EXPECT_EQ(zero, one & zero); 331 EXPECT_EQ(zero, zero & one); 332 EXPECT_EQ(one, one & one); 333 EXPECT_EQ(zero, zero & zero); 334 EXPECT_EQ(zero, neg_one & zero); 335 EXPECT_EQ(zero, zero & neg_one); 336 EXPECT_EQ(neg_one, neg_one & neg_one); 337 338 // Or 339 EXPECT_EQ(zero, zero | zero); 340 EXPECT_EQ(one, one | zero); 341 EXPECT_EQ(one, zero | one); 342 EXPECT_EQ(one, one | one); 343 EXPECT_EQ(zero, zero | zero); 344 EXPECT_EQ(neg_one, neg_one | zero); 345 EXPECT_EQ(neg_one, zero | neg_one); 346 EXPECT_EQ(neg_one, neg_one | neg_one); 347 348 // Xor 349 EXPECT_EQ(zero, zero ^ zero); 350 EXPECT_EQ(one, one ^ zero); 351 EXPECT_EQ(one, zero ^ one); 352 EXPECT_EQ(zero, one ^ one); 353 EXPECT_EQ(zero, zero ^ zero); 354 EXPECT_EQ(neg_one, neg_one ^ zero); 355 EXPECT_EQ(neg_one, zero ^ neg_one); 356 EXPECT_EQ(zero, neg_one ^ neg_one); 357 358 // Shifts. 359 EXPECT_EQ(zero, one << one); 360 EXPECT_EQ(one, one << zero); 361 EXPECT_EQ(zero, one.shl(1)); 362 EXPECT_EQ(one, one.shl(0)); 363 EXPECT_EQ(zero, one.lshr(1)); 364 EXPECT_EQ(one, one.ashr(1)); 365 366 // Rotates. 367 EXPECT_EQ(one, one.rotl(0)); 368 EXPECT_EQ(one, one.rotl(1)); 369 EXPECT_EQ(one, one.rotr(0)); 370 EXPECT_EQ(one, one.rotr(1)); 371 372 // Multiplies. 373 EXPECT_EQ(neg_one, neg_one * one); 374 EXPECT_EQ(neg_one, one * neg_one); 375 EXPECT_EQ(one, neg_one * neg_one); 376 EXPECT_EQ(one, one * one); 377 378 // Divides. 379 EXPECT_EQ(neg_one, one.sdiv(neg_one)); 380 EXPECT_EQ(neg_one, neg_one.sdiv(one)); 381 EXPECT_EQ(one, neg_one.sdiv(neg_one)); 382 EXPECT_EQ(one, one.sdiv(one)); 383 384 EXPECT_EQ(neg_one, one.udiv(neg_one)); 385 EXPECT_EQ(neg_one, neg_one.udiv(one)); 386 EXPECT_EQ(one, neg_one.udiv(neg_one)); 387 EXPECT_EQ(one, one.udiv(one)); 388 389 // Remainders. 390 EXPECT_EQ(zero, neg_one.srem(one)); 391 EXPECT_EQ(zero, neg_one.urem(one)); 392 EXPECT_EQ(zero, one.srem(neg_one)); 393 394 // sdivrem 395 { 396 APInt q(8, 0); 397 APInt r(8, 0); 398 APInt one(8, 1); 399 APInt two(8, 2); 400 APInt nine(8, 9); 401 APInt four(8, 4); 402 403 EXPECT_EQ(nine.srem(two), one); 404 EXPECT_EQ(nine.srem(-two), one); 405 EXPECT_EQ((-nine).srem(two), -one); 406 EXPECT_EQ((-nine).srem(-two), -one); 407 408 APInt::sdivrem(nine, two, q, r); 409 EXPECT_EQ(four, q); 410 EXPECT_EQ(one, r); 411 APInt::sdivrem(-nine, two, q, r); 412 EXPECT_EQ(-four, q); 413 EXPECT_EQ(-one, r); 414 APInt::sdivrem(nine, -two, q, r); 415 EXPECT_EQ(-four, q); 416 EXPECT_EQ(one, r); 417 APInt::sdivrem(-nine, -two, q, r); 418 EXPECT_EQ(four, q); 419 EXPECT_EQ(-one, r); 420 } 421 } 422 423 TEST(APIntTest, compare) { 424 std::array<APInt, 5> testVals{{ 425 APInt{16, 2}, 426 APInt{16, 1}, 427 APInt{16, 0}, 428 APInt{16, (uint64_t)-1, true}, 429 APInt{16, (uint64_t)-2, true}, 430 }}; 431 432 for (auto &arg1 : testVals) 433 for (auto &arg2 : testVals) { 434 auto uv1 = arg1.getZExtValue(); 435 auto uv2 = arg2.getZExtValue(); 436 auto sv1 = arg1.getSExtValue(); 437 auto sv2 = arg2.getSExtValue(); 438 439 EXPECT_EQ(uv1 < uv2, arg1.ult(arg2)); 440 EXPECT_EQ(uv1 <= uv2, arg1.ule(arg2)); 441 EXPECT_EQ(uv1 > uv2, arg1.ugt(arg2)); 442 EXPECT_EQ(uv1 >= uv2, arg1.uge(arg2)); 443 444 EXPECT_EQ(sv1 < sv2, arg1.slt(arg2)); 445 EXPECT_EQ(sv1 <= sv2, arg1.sle(arg2)); 446 EXPECT_EQ(sv1 > sv2, arg1.sgt(arg2)); 447 EXPECT_EQ(sv1 >= sv2, arg1.sge(arg2)); 448 449 EXPECT_EQ(uv1 < uv2, arg1.ult(uv2)); 450 EXPECT_EQ(uv1 <= uv2, arg1.ule(uv2)); 451 EXPECT_EQ(uv1 > uv2, arg1.ugt(uv2)); 452 EXPECT_EQ(uv1 >= uv2, arg1.uge(uv2)); 453 454 EXPECT_EQ(sv1 < sv2, arg1.slt(sv2)); 455 EXPECT_EQ(sv1 <= sv2, arg1.sle(sv2)); 456 EXPECT_EQ(sv1 > sv2, arg1.sgt(sv2)); 457 EXPECT_EQ(sv1 >= sv2, arg1.sge(sv2)); 458 } 459 } 460 461 TEST(APIntTest, compareWithRawIntegers) { 462 EXPECT_TRUE(!APInt(8, 1).uge(256)); 463 EXPECT_TRUE(!APInt(8, 1).ugt(256)); 464 EXPECT_TRUE( APInt(8, 1).ule(256)); 465 EXPECT_TRUE( APInt(8, 1).ult(256)); 466 EXPECT_TRUE(!APInt(8, 1).sge(256)); 467 EXPECT_TRUE(!APInt(8, 1).sgt(256)); 468 EXPECT_TRUE( APInt(8, 1).sle(256)); 469 EXPECT_TRUE( APInt(8, 1).slt(256)); 470 EXPECT_TRUE(!(APInt(8, 0) == 256)); 471 EXPECT_TRUE( APInt(8, 0) != 256); 472 EXPECT_TRUE(!(APInt(8, 1) == 256)); 473 EXPECT_TRUE( APInt(8, 1) != 256); 474 475 auto uint64max = UINT64_MAX; 476 auto int64max = INT64_MAX; 477 auto int64min = INT64_MIN; 478 479 auto u64 = APInt{128, uint64max}; 480 auto s64 = APInt{128, static_cast<uint64_t>(int64max), true}; 481 auto big = u64 + 1; 482 483 EXPECT_TRUE( u64.uge(uint64max)); 484 EXPECT_TRUE(!u64.ugt(uint64max)); 485 EXPECT_TRUE( u64.ule(uint64max)); 486 EXPECT_TRUE(!u64.ult(uint64max)); 487 EXPECT_TRUE( u64.sge(int64max)); 488 EXPECT_TRUE( u64.sgt(int64max)); 489 EXPECT_TRUE(!u64.sle(int64max)); 490 EXPECT_TRUE(!u64.slt(int64max)); 491 EXPECT_TRUE( u64.sge(int64min)); 492 EXPECT_TRUE( u64.sgt(int64min)); 493 EXPECT_TRUE(!u64.sle(int64min)); 494 EXPECT_TRUE(!u64.slt(int64min)); 495 496 EXPECT_TRUE(u64 == uint64max); 497 EXPECT_TRUE(u64 != int64max); 498 EXPECT_TRUE(u64 != int64min); 499 500 EXPECT_TRUE(!s64.uge(uint64max)); 501 EXPECT_TRUE(!s64.ugt(uint64max)); 502 EXPECT_TRUE( s64.ule(uint64max)); 503 EXPECT_TRUE( s64.ult(uint64max)); 504 EXPECT_TRUE( s64.sge(int64max)); 505 EXPECT_TRUE(!s64.sgt(int64max)); 506 EXPECT_TRUE( s64.sle(int64max)); 507 EXPECT_TRUE(!s64.slt(int64max)); 508 EXPECT_TRUE( s64.sge(int64min)); 509 EXPECT_TRUE( s64.sgt(int64min)); 510 EXPECT_TRUE(!s64.sle(int64min)); 511 EXPECT_TRUE(!s64.slt(int64min)); 512 513 EXPECT_TRUE(s64 != uint64max); 514 EXPECT_TRUE(s64 == int64max); 515 EXPECT_TRUE(s64 != int64min); 516 517 EXPECT_TRUE( big.uge(uint64max)); 518 EXPECT_TRUE( big.ugt(uint64max)); 519 EXPECT_TRUE(!big.ule(uint64max)); 520 EXPECT_TRUE(!big.ult(uint64max)); 521 EXPECT_TRUE( big.sge(int64max)); 522 EXPECT_TRUE( big.sgt(int64max)); 523 EXPECT_TRUE(!big.sle(int64max)); 524 EXPECT_TRUE(!big.slt(int64max)); 525 EXPECT_TRUE( big.sge(int64min)); 526 EXPECT_TRUE( big.sgt(int64min)); 527 EXPECT_TRUE(!big.sle(int64min)); 528 EXPECT_TRUE(!big.slt(int64min)); 529 530 EXPECT_TRUE(big != uint64max); 531 EXPECT_TRUE(big != int64max); 532 EXPECT_TRUE(big != int64min); 533 } 534 535 TEST(APIntTest, compareWithInt64Min) { 536 int64_t edge = INT64_MIN; 537 int64_t edgeP1 = edge + 1; 538 int64_t edgeM1 = INT64_MAX; 539 auto a = APInt{64, static_cast<uint64_t>(edge), true}; 540 541 EXPECT_TRUE(!a.slt(edge)); 542 EXPECT_TRUE( a.sle(edge)); 543 EXPECT_TRUE(!a.sgt(edge)); 544 EXPECT_TRUE( a.sge(edge)); 545 EXPECT_TRUE( a.slt(edgeP1)); 546 EXPECT_TRUE( a.sle(edgeP1)); 547 EXPECT_TRUE(!a.sgt(edgeP1)); 548 EXPECT_TRUE(!a.sge(edgeP1)); 549 EXPECT_TRUE( a.slt(edgeM1)); 550 EXPECT_TRUE( a.sle(edgeM1)); 551 EXPECT_TRUE(!a.sgt(edgeM1)); 552 EXPECT_TRUE(!a.sge(edgeM1)); 553 } 554 555 TEST(APIntTest, compareWithHalfInt64Max) { 556 uint64_t edge = 0x4000000000000000; 557 uint64_t edgeP1 = edge + 1; 558 uint64_t edgeM1 = edge - 1; 559 auto a = APInt{64, edge}; 560 561 EXPECT_TRUE(!a.ult(edge)); 562 EXPECT_TRUE( a.ule(edge)); 563 EXPECT_TRUE(!a.ugt(edge)); 564 EXPECT_TRUE( a.uge(edge)); 565 EXPECT_TRUE( a.ult(edgeP1)); 566 EXPECT_TRUE( a.ule(edgeP1)); 567 EXPECT_TRUE(!a.ugt(edgeP1)); 568 EXPECT_TRUE(!a.uge(edgeP1)); 569 EXPECT_TRUE(!a.ult(edgeM1)); 570 EXPECT_TRUE(!a.ule(edgeM1)); 571 EXPECT_TRUE( a.ugt(edgeM1)); 572 EXPECT_TRUE( a.uge(edgeM1)); 573 574 EXPECT_TRUE(!a.slt(edge)); 575 EXPECT_TRUE( a.sle(edge)); 576 EXPECT_TRUE(!a.sgt(edge)); 577 EXPECT_TRUE( a.sge(edge)); 578 EXPECT_TRUE( a.slt(edgeP1)); 579 EXPECT_TRUE( a.sle(edgeP1)); 580 EXPECT_TRUE(!a.sgt(edgeP1)); 581 EXPECT_TRUE(!a.sge(edgeP1)); 582 EXPECT_TRUE(!a.slt(edgeM1)); 583 EXPECT_TRUE(!a.sle(edgeM1)); 584 EXPECT_TRUE( a.sgt(edgeM1)); 585 EXPECT_TRUE( a.sge(edgeM1)); 586 } 587 588 TEST(APIntTest, compareLargeIntegers) { 589 // Make sure all the combinations of signed comparisons work with big ints. 590 auto One = APInt{128, static_cast<uint64_t>(1), true}; 591 auto Two = APInt{128, static_cast<uint64_t>(2), true}; 592 auto MinusOne = APInt{128, static_cast<uint64_t>(-1), true}; 593 auto MinusTwo = APInt{128, static_cast<uint64_t>(-2), true}; 594 595 EXPECT_TRUE(!One.slt(One)); 596 EXPECT_TRUE(!Two.slt(One)); 597 EXPECT_TRUE(MinusOne.slt(One)); 598 EXPECT_TRUE(MinusTwo.slt(One)); 599 600 EXPECT_TRUE(One.slt(Two)); 601 EXPECT_TRUE(!Two.slt(Two)); 602 EXPECT_TRUE(MinusOne.slt(Two)); 603 EXPECT_TRUE(MinusTwo.slt(Two)); 604 605 EXPECT_TRUE(!One.slt(MinusOne)); 606 EXPECT_TRUE(!Two.slt(MinusOne)); 607 EXPECT_TRUE(!MinusOne.slt(MinusOne)); 608 EXPECT_TRUE(MinusTwo.slt(MinusOne)); 609 610 EXPECT_TRUE(!One.slt(MinusTwo)); 611 EXPECT_TRUE(!Two.slt(MinusTwo)); 612 EXPECT_TRUE(!MinusOne.slt(MinusTwo)); 613 EXPECT_TRUE(!MinusTwo.slt(MinusTwo)); 614 } 615 616 TEST(APIntTest, binaryOpsWithRawIntegers) { 617 // Single word check. 618 uint64_t E1 = 0x2CA7F46BF6569915ULL; 619 APInt A1(64, E1); 620 621 EXPECT_EQ(A1 & E1, E1); 622 EXPECT_EQ(A1 & 0, 0); 623 EXPECT_EQ(A1 & 1, 1); 624 EXPECT_EQ(A1 & 5, 5); 625 EXPECT_EQ(A1 & UINT64_MAX, E1); 626 627 EXPECT_EQ(A1 | E1, E1); 628 EXPECT_EQ(A1 | 0, E1); 629 EXPECT_EQ(A1 | 1, E1); 630 EXPECT_EQ(A1 | 2, E1 | 2); 631 EXPECT_EQ(A1 | UINT64_MAX, UINT64_MAX); 632 633 EXPECT_EQ(A1 ^ E1, 0); 634 EXPECT_EQ(A1 ^ 0, E1); 635 EXPECT_EQ(A1 ^ 1, E1 ^ 1); 636 EXPECT_EQ(A1 ^ 7, E1 ^ 7); 637 EXPECT_EQ(A1 ^ UINT64_MAX, ~E1); 638 639 // Multiword check. 640 uint64_t N = 0xEB6EB136591CBA21ULL; 641 APInt::WordType E2[4] = { 642 N, 643 0x7B9358BD6A33F10AULL, 644 0x7E7FFA5EADD8846ULL, 645 0x305F341CA00B613DULL 646 }; 647 APInt A2(APInt::APINT_BITS_PER_WORD*4, E2); 648 649 EXPECT_EQ(A2 & N, N); 650 EXPECT_EQ(A2 & 0, 0); 651 EXPECT_EQ(A2 & 1, 1); 652 EXPECT_EQ(A2 & 5, 1); 653 EXPECT_EQ(A2 & UINT64_MAX, N); 654 655 EXPECT_EQ(A2 | N, A2); 656 EXPECT_EQ(A2 | 0, A2); 657 EXPECT_EQ(A2 | 1, A2); 658 EXPECT_EQ(A2 | 2, A2 + 2); 659 EXPECT_EQ(A2 | UINT64_MAX, A2 - N + UINT64_MAX); 660 661 EXPECT_EQ(A2 ^ N, A2 - N); 662 EXPECT_EQ(A2 ^ 0, A2); 663 EXPECT_EQ(A2 ^ 1, A2 - 1); 664 EXPECT_EQ(A2 ^ 7, A2 + 5); 665 EXPECT_EQ(A2 ^ UINT64_MAX, A2 - N + ~N); 666 } 667 668 TEST(APIntTest, rvalue_arithmetic) { 669 // Test all combinations of lvalue/rvalue lhs/rhs of add/sub 670 671 // Lamdba to return an APInt by value, but also provide the raw value of the 672 // allocated data. 673 auto getRValue = [](const char *HexString, uint64_t const *&RawData) { 674 APInt V(129, HexString, 16); 675 RawData = V.getRawData(); 676 return V; 677 }; 678 679 APInt One(129, "1", 16); 680 APInt Two(129, "2", 16); 681 APInt Three(129, "3", 16); 682 APInt MinusOne = -One; 683 684 const uint64_t *RawDataL = nullptr; 685 const uint64_t *RawDataR = nullptr; 686 687 { 688 // 1 + 1 = 2 689 APInt AddLL = One + One; 690 EXPECT_EQ(AddLL, Two); 691 692 APInt AddLR = One + getRValue("1", RawDataR); 693 EXPECT_EQ(AddLR, Two); 694 EXPECT_EQ(AddLR.getRawData(), RawDataR); 695 696 APInt AddRL = getRValue("1", RawDataL) + One; 697 EXPECT_EQ(AddRL, Two); 698 EXPECT_EQ(AddRL.getRawData(), RawDataL); 699 700 APInt AddRR = getRValue("1", RawDataL) + getRValue("1", RawDataR); 701 EXPECT_EQ(AddRR, Two); 702 EXPECT_EQ(AddRR.getRawData(), RawDataR); 703 704 // LValue's and constants 705 APInt AddLK = One + 1; 706 EXPECT_EQ(AddLK, Two); 707 708 APInt AddKL = 1 + One; 709 EXPECT_EQ(AddKL, Two); 710 711 // RValue's and constants 712 APInt AddRK = getRValue("1", RawDataL) + 1; 713 EXPECT_EQ(AddRK, Two); 714 EXPECT_EQ(AddRK.getRawData(), RawDataL); 715 716 APInt AddKR = 1 + getRValue("1", RawDataR); 717 EXPECT_EQ(AddKR, Two); 718 EXPECT_EQ(AddKR.getRawData(), RawDataR); 719 } 720 721 { 722 // 0x0,FFFF...FFFF + 0x2 = 0x100...0001 723 APInt AllOnes(129, "0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16); 724 APInt HighOneLowOne(129, "100000000000000000000000000000001", 16); 725 726 APInt AddLL = AllOnes + Two; 727 EXPECT_EQ(AddLL, HighOneLowOne); 728 729 APInt AddLR = AllOnes + getRValue("2", RawDataR); 730 EXPECT_EQ(AddLR, HighOneLowOne); 731 EXPECT_EQ(AddLR.getRawData(), RawDataR); 732 733 APInt AddRL = getRValue("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataL) + Two; 734 EXPECT_EQ(AddRL, HighOneLowOne); 735 EXPECT_EQ(AddRL.getRawData(), RawDataL); 736 737 APInt AddRR = getRValue("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataL) + 738 getRValue("2", RawDataR); 739 EXPECT_EQ(AddRR, HighOneLowOne); 740 EXPECT_EQ(AddRR.getRawData(), RawDataR); 741 742 // LValue's and constants 743 APInt AddLK = AllOnes + 2; 744 EXPECT_EQ(AddLK, HighOneLowOne); 745 746 APInt AddKL = 2 + AllOnes; 747 EXPECT_EQ(AddKL, HighOneLowOne); 748 749 // RValue's and constants 750 APInt AddRK = getRValue("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataL) + 2; 751 EXPECT_EQ(AddRK, HighOneLowOne); 752 EXPECT_EQ(AddRK.getRawData(), RawDataL); 753 754 APInt AddKR = 2 + getRValue("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataR); 755 EXPECT_EQ(AddKR, HighOneLowOne); 756 EXPECT_EQ(AddKR.getRawData(), RawDataR); 757 } 758 759 { 760 // 2 - 1 = 1 761 APInt SubLL = Two - One; 762 EXPECT_EQ(SubLL, One); 763 764 APInt SubLR = Two - getRValue("1", RawDataR); 765 EXPECT_EQ(SubLR, One); 766 EXPECT_EQ(SubLR.getRawData(), RawDataR); 767 768 APInt SubRL = getRValue("2", RawDataL) - One; 769 EXPECT_EQ(SubRL, One); 770 EXPECT_EQ(SubRL.getRawData(), RawDataL); 771 772 APInt SubRR = getRValue("2", RawDataL) - getRValue("1", RawDataR); 773 EXPECT_EQ(SubRR, One); 774 EXPECT_EQ(SubRR.getRawData(), RawDataR); 775 776 // LValue's and constants 777 APInt SubLK = Two - 1; 778 EXPECT_EQ(SubLK, One); 779 780 APInt SubKL = 2 - One; 781 EXPECT_EQ(SubKL, One); 782 783 // RValue's and constants 784 APInt SubRK = getRValue("2", RawDataL) - 1; 785 EXPECT_EQ(SubRK, One); 786 EXPECT_EQ(SubRK.getRawData(), RawDataL); 787 788 APInt SubKR = 2 - getRValue("1", RawDataR); 789 EXPECT_EQ(SubKR, One); 790 EXPECT_EQ(SubKR.getRawData(), RawDataR); 791 } 792 793 { 794 // 0x100...0001 - 0x0,FFFF...FFFF = 0x2 795 APInt AllOnes(129, "0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16); 796 APInt HighOneLowOne(129, "100000000000000000000000000000001", 16); 797 798 APInt SubLL = HighOneLowOne - AllOnes; 799 EXPECT_EQ(SubLL, Two); 800 801 APInt SubLR = HighOneLowOne - 802 getRValue("0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataR); 803 EXPECT_EQ(SubLR, Two); 804 EXPECT_EQ(SubLR.getRawData(), RawDataR); 805 806 APInt SubRL = getRValue("100000000000000000000000000000001", RawDataL) - 807 AllOnes; 808 EXPECT_EQ(SubRL, Two); 809 EXPECT_EQ(SubRL.getRawData(), RawDataL); 810 811 APInt SubRR = getRValue("100000000000000000000000000000001", RawDataL) - 812 getRValue("0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataR); 813 EXPECT_EQ(SubRR, Two); 814 EXPECT_EQ(SubRR.getRawData(), RawDataR); 815 816 // LValue's and constants 817 // 0x100...0001 - 0x2 = 0x0,FFFF...FFFF 818 APInt SubLK = HighOneLowOne - 2; 819 EXPECT_EQ(SubLK, AllOnes); 820 821 // 2 - (-1) = 3 822 APInt SubKL = 2 - MinusOne; 823 EXPECT_EQ(SubKL, Three); 824 825 // RValue's and constants 826 // 0x100...0001 - 0x2 = 0x0,FFFF...FFFF 827 APInt SubRK = getRValue("100000000000000000000000000000001", RawDataL) - 2; 828 EXPECT_EQ(SubRK, AllOnes); 829 EXPECT_EQ(SubRK.getRawData(), RawDataL); 830 831 APInt SubKR = 2 - getRValue("1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataR); 832 EXPECT_EQ(SubKR, Three); 833 EXPECT_EQ(SubKR.getRawData(), RawDataR); 834 } 835 } 836 837 TEST(APIntTest, rvalue_bitwise) { 838 // Test all combinations of lvalue/rvalue lhs/rhs of and/or/xor 839 840 // Lamdba to return an APInt by value, but also provide the raw value of the 841 // allocated data. 842 auto getRValue = [](const char *HexString, uint64_t const *&RawData) { 843 APInt V(129, HexString, 16); 844 RawData = V.getRawData(); 845 return V; 846 }; 847 848 APInt Ten(129, "A", 16); 849 APInt Twelve(129, "C", 16); 850 851 const uint64_t *RawDataL = nullptr; 852 const uint64_t *RawDataR = nullptr; 853 854 { 855 // 12 & 10 = 8 856 APInt AndLL = Ten & Twelve; 857 EXPECT_EQ(AndLL, 0x8); 858 859 APInt AndLR = Ten & getRValue("C", RawDataR); 860 EXPECT_EQ(AndLR, 0x8); 861 EXPECT_EQ(AndLR.getRawData(), RawDataR); 862 863 APInt AndRL = getRValue("A", RawDataL) & Twelve; 864 EXPECT_EQ(AndRL, 0x8); 865 EXPECT_EQ(AndRL.getRawData(), RawDataL); 866 867 APInt AndRR = getRValue("A", RawDataL) & getRValue("C", RawDataR); 868 EXPECT_EQ(AndRR, 0x8); 869 EXPECT_EQ(AndRR.getRawData(), RawDataR); 870 871 // LValue's and constants 872 APInt AndLK = Ten & 0xc; 873 EXPECT_EQ(AndLK, 0x8); 874 875 APInt AndKL = 0xa & Twelve; 876 EXPECT_EQ(AndKL, 0x8); 877 878 // RValue's and constants 879 APInt AndRK = getRValue("A", RawDataL) & 0xc; 880 EXPECT_EQ(AndRK, 0x8); 881 EXPECT_EQ(AndRK.getRawData(), RawDataL); 882 883 APInt AndKR = 0xa & getRValue("C", RawDataR); 884 EXPECT_EQ(AndKR, 0x8); 885 EXPECT_EQ(AndKR.getRawData(), RawDataR); 886 } 887 888 { 889 // 12 | 10 = 14 890 APInt OrLL = Ten | Twelve; 891 EXPECT_EQ(OrLL, 0xe); 892 893 APInt OrLR = Ten | getRValue("C", RawDataR); 894 EXPECT_EQ(OrLR, 0xe); 895 EXPECT_EQ(OrLR.getRawData(), RawDataR); 896 897 APInt OrRL = getRValue("A", RawDataL) | Twelve; 898 EXPECT_EQ(OrRL, 0xe); 899 EXPECT_EQ(OrRL.getRawData(), RawDataL); 900 901 APInt OrRR = getRValue("A", RawDataL) | getRValue("C", RawDataR); 902 EXPECT_EQ(OrRR, 0xe); 903 EXPECT_EQ(OrRR.getRawData(), RawDataR); 904 905 // LValue's and constants 906 APInt OrLK = Ten | 0xc; 907 EXPECT_EQ(OrLK, 0xe); 908 909 APInt OrKL = 0xa | Twelve; 910 EXPECT_EQ(OrKL, 0xe); 911 912 // RValue's and constants 913 APInt OrRK = getRValue("A", RawDataL) | 0xc; 914 EXPECT_EQ(OrRK, 0xe); 915 EXPECT_EQ(OrRK.getRawData(), RawDataL); 916 917 APInt OrKR = 0xa | getRValue("C", RawDataR); 918 EXPECT_EQ(OrKR, 0xe); 919 EXPECT_EQ(OrKR.getRawData(), RawDataR); 920 } 921 922 { 923 // 12 ^ 10 = 6 924 APInt XorLL = Ten ^ Twelve; 925 EXPECT_EQ(XorLL, 0x6); 926 927 APInt XorLR = Ten ^ getRValue("C", RawDataR); 928 EXPECT_EQ(XorLR, 0x6); 929 EXPECT_EQ(XorLR.getRawData(), RawDataR); 930 931 APInt XorRL = getRValue("A", RawDataL) ^ Twelve; 932 EXPECT_EQ(XorRL, 0x6); 933 EXPECT_EQ(XorRL.getRawData(), RawDataL); 934 935 APInt XorRR = getRValue("A", RawDataL) ^ getRValue("C", RawDataR); 936 EXPECT_EQ(XorRR, 0x6); 937 EXPECT_EQ(XorRR.getRawData(), RawDataR); 938 939 // LValue's and constants 940 APInt XorLK = Ten ^ 0xc; 941 EXPECT_EQ(XorLK, 0x6); 942 943 APInt XorKL = 0xa ^ Twelve; 944 EXPECT_EQ(XorKL, 0x6); 945 946 // RValue's and constants 947 APInt XorRK = getRValue("A", RawDataL) ^ 0xc; 948 EXPECT_EQ(XorRK, 0x6); 949 EXPECT_EQ(XorRK.getRawData(), RawDataL); 950 951 APInt XorKR = 0xa ^ getRValue("C", RawDataR); 952 EXPECT_EQ(XorKR, 0x6); 953 EXPECT_EQ(XorKR.getRawData(), RawDataR); 954 } 955 } 956 957 TEST(APIntTest, rvalue_invert) { 958 // Lamdba to return an APInt by value, but also provide the raw value of the 959 // allocated data. 960 auto getRValue = [](const char *HexString, uint64_t const *&RawData) { 961 APInt V(129, HexString, 16); 962 RawData = V.getRawData(); 963 return V; 964 }; 965 966 APInt One(129, 1); 967 APInt NegativeTwo(129, -2ULL, true); 968 969 const uint64_t *RawData = nullptr; 970 971 { 972 // ~1 = -2 973 APInt NegL = ~One; 974 EXPECT_EQ(NegL, NegativeTwo); 975 976 APInt NegR = ~getRValue("1", RawData); 977 EXPECT_EQ(NegR, NegativeTwo); 978 EXPECT_EQ(NegR.getRawData(), RawData); 979 } 980 } 981 982 // Tests different div/rem varaints using scheme (a * b + c) / a 983 void testDiv(APInt a, APInt b, APInt c) { 984 ASSERT_TRUE(a.uge(b)); // Must: a >= b 985 ASSERT_TRUE(a.ugt(c)); // Must: a > c 986 987 auto p = a * b + c; 988 989 auto q = p.udiv(a); 990 auto r = p.urem(a); 991 EXPECT_EQ(b, q); 992 EXPECT_EQ(c, r); 993 APInt::udivrem(p, a, q, r); 994 EXPECT_EQ(b, q); 995 EXPECT_EQ(c, r); 996 q = p.sdiv(a); 997 r = p.srem(a); 998 EXPECT_EQ(b, q); 999 EXPECT_EQ(c, r); 1000 APInt::sdivrem(p, a, q, r); 1001 EXPECT_EQ(b, q); 1002 EXPECT_EQ(c, r); 1003 1004 if (b.ugt(c)) { // Test also symmetric case 1005 q = p.udiv(b); 1006 r = p.urem(b); 1007 EXPECT_EQ(a, q); 1008 EXPECT_EQ(c, r); 1009 APInt::udivrem(p, b, q, r); 1010 EXPECT_EQ(a, q); 1011 EXPECT_EQ(c, r); 1012 q = p.sdiv(b); 1013 r = p.srem(b); 1014 EXPECT_EQ(a, q); 1015 EXPECT_EQ(c, r); 1016 APInt::sdivrem(p, b, q, r); 1017 EXPECT_EQ(a, q); 1018 EXPECT_EQ(c, r); 1019 } 1020 } 1021 1022 TEST(APIntTest, divrem_big1) { 1023 // Tests KnuthDiv rare step D6 1024 testDiv({256, "1ffffffffffffffff", 16}, 1025 {256, "1ffffffffffffffff", 16}, 1026 {256, 0}); 1027 } 1028 1029 TEST(APIntTest, divrem_big2) { 1030 // Tests KnuthDiv rare step D6 1031 testDiv({1024, "112233ceff" 1032 "cecece000000ffffffffffffffffffff" 1033 "ffffffffffffffffffffffffffffffff" 1034 "ffffffffffffffffffffffffffffffff" 1035 "ffffffffffffffffffffffffffffff33", 16}, 1036 {1024, "111111ffffffffffffffff" 1037 "ffffffffffffffffffffffffffffffff" 1038 "fffffffffffffffffffffffffffffccf" 1039 "ffffffffffffffffffffffffffffff00", 16}, 1040 {1024, 7919}); 1041 } 1042 1043 TEST(APIntTest, divrem_big3) { 1044 // Tests KnuthDiv case without shift 1045 testDiv({256, "80000001ffffffffffffffff", 16}, 1046 {256, "ffffffffffffff0000000", 16}, 1047 {256, 4219}); 1048 } 1049 1050 TEST(APIntTest, divrem_big4) { 1051 // Tests heap allocation in divide() enfoced by huge numbers 1052 testDiv(APInt{4096, 5}.shl(2001), 1053 APInt{4096, 1}.shl(2000), 1054 APInt{4096, 4219*13}); 1055 } 1056 1057 TEST(APIntTest, divrem_big5) { 1058 // Tests one word divisor case of divide() 1059 testDiv(APInt{1024, 19}.shl(811), 1060 APInt{1024, 4356013}, // one word 1061 APInt{1024, 1}); 1062 } 1063 1064 TEST(APIntTest, divrem_big6) { 1065 // Tests some rare "borrow" cases in D4 step 1066 testDiv(APInt{512, "ffffffffffffffff00000000000000000000000001", 16}, 1067 APInt{512, "10000000000000001000000000000001", 16}, 1068 APInt{512, "10000000000000000000000000000000", 16}); 1069 } 1070 1071 TEST(APIntTest, divrem_big7) { 1072 // Yet another test for KnuthDiv rare step D6. 1073 testDiv({224, "800000008000000200000005", 16}, 1074 {224, "fffffffd", 16}, 1075 {224, "80000000800000010000000f", 16}); 1076 } 1077 1078 void testDiv(APInt a, uint64_t b, APInt c) { 1079 auto p = a * b + c; 1080 1081 APInt q; 1082 uint64_t r; 1083 // Unsigned division will only work if our original number wasn't negative. 1084 if (!a.isNegative()) { 1085 q = p.udiv(b); 1086 r = p.urem(b); 1087 EXPECT_EQ(a, q); 1088 EXPECT_EQ(c, r); 1089 APInt::udivrem(p, b, q, r); 1090 EXPECT_EQ(a, q); 1091 EXPECT_EQ(c, r); 1092 } 1093 q = p.sdiv(b); 1094 r = p.srem(b); 1095 EXPECT_EQ(a, q); 1096 if (c.isNegative()) 1097 EXPECT_EQ(-c, -r); // Need to negate so the uint64_t compare will work. 1098 else 1099 EXPECT_EQ(c, r); 1100 int64_t sr; 1101 APInt::sdivrem(p, b, q, sr); 1102 EXPECT_EQ(a, q); 1103 if (c.isNegative()) 1104 EXPECT_EQ(-c, -sr); // Need to negate so the uint64_t compare will work. 1105 else 1106 EXPECT_EQ(c, sr); 1107 } 1108 1109 TEST(APIntTest, divremuint) { 1110 // Single word APInt 1111 testDiv(APInt{64, 9}, 1112 2, 1113 APInt{64, 1}); 1114 1115 // Single word negative APInt 1116 testDiv(-APInt{64, 9}, 1117 2, 1118 -APInt{64, 1}); 1119 1120 // Multiword dividend with only one significant word. 1121 testDiv(APInt{256, 9}, 1122 2, 1123 APInt{256, 1}); 1124 1125 // Negative dividend. 1126 testDiv(-APInt{256, 9}, 1127 2, 1128 -APInt{256, 1}); 1129 1130 // Multiword dividend 1131 testDiv(APInt{1024, 19}.shl(811), 1132 4356013, // one word 1133 APInt{1024, 1}); 1134 } 1135 1136 TEST(APIntTest, divrem_simple) { 1137 // Test simple cases. 1138 APInt A(65, 2), B(65, 2); 1139 APInt Q, R; 1140 1141 // X / X 1142 APInt::sdivrem(A, B, Q, R); 1143 EXPECT_EQ(Q, APInt(65, 1)); 1144 EXPECT_EQ(R, APInt(65, 0)); 1145 APInt::udivrem(A, B, Q, R); 1146 EXPECT_EQ(Q, APInt(65, 1)); 1147 EXPECT_EQ(R, APInt(65, 0)); 1148 1149 // 0 / X 1150 APInt O(65, 0); 1151 APInt::sdivrem(O, B, Q, R); 1152 EXPECT_EQ(Q, APInt(65, 0)); 1153 EXPECT_EQ(R, APInt(65, 0)); 1154 APInt::udivrem(O, B, Q, R); 1155 EXPECT_EQ(Q, APInt(65, 0)); 1156 EXPECT_EQ(R, APInt(65, 0)); 1157 1158 // X / 1 1159 APInt I(65, 1); 1160 APInt::sdivrem(A, I, Q, R); 1161 EXPECT_EQ(Q, A); 1162 EXPECT_EQ(R, APInt(65, 0)); 1163 APInt::udivrem(A, I, Q, R); 1164 EXPECT_EQ(Q, A); 1165 EXPECT_EQ(R, APInt(65, 0)); 1166 } 1167 1168 TEST(APIntTest, fromString) { 1169 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 2)); 1170 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 2)); 1171 EXPECT_EQ(APInt(32, 2), APInt(32, "10", 2)); 1172 EXPECT_EQ(APInt(32, 3), APInt(32, "11", 2)); 1173 EXPECT_EQ(APInt(32, 4), APInt(32, "100", 2)); 1174 1175 EXPECT_EQ(APInt(32, 0), APInt(32, "+0", 2)); 1176 EXPECT_EQ(APInt(32, 1), APInt(32, "+1", 2)); 1177 EXPECT_EQ(APInt(32, 2), APInt(32, "+10", 2)); 1178 EXPECT_EQ(APInt(32, 3), APInt(32, "+11", 2)); 1179 EXPECT_EQ(APInt(32, 4), APInt(32, "+100", 2)); 1180 1181 EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 2)); 1182 EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 2)); 1183 EXPECT_EQ(APInt(32, uint32_t(-2LL)), APInt(32, "-10", 2)); 1184 EXPECT_EQ(APInt(32, uint32_t(-3LL)), APInt(32, "-11", 2)); 1185 EXPECT_EQ(APInt(32, uint32_t(-4LL)), APInt(32, "-100", 2)); 1186 1187 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 8)); 1188 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 8)); 1189 EXPECT_EQ(APInt(32, 7), APInt(32, "7", 8)); 1190 EXPECT_EQ(APInt(32, 8), APInt(32, "10", 8)); 1191 EXPECT_EQ(APInt(32, 15), APInt(32, "17", 8)); 1192 EXPECT_EQ(APInt(32, 16), APInt(32, "20", 8)); 1193 1194 EXPECT_EQ(APInt(32, +0), APInt(32, "+0", 8)); 1195 EXPECT_EQ(APInt(32, +1), APInt(32, "+1", 8)); 1196 EXPECT_EQ(APInt(32, +7), APInt(32, "+7", 8)); 1197 EXPECT_EQ(APInt(32, +8), APInt(32, "+10", 8)); 1198 EXPECT_EQ(APInt(32, +15), APInt(32, "+17", 8)); 1199 EXPECT_EQ(APInt(32, +16), APInt(32, "+20", 8)); 1200 1201 EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 8)); 1202 EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 8)); 1203 EXPECT_EQ(APInt(32, uint32_t(-7LL)), APInt(32, "-7", 8)); 1204 EXPECT_EQ(APInt(32, uint32_t(-8LL)), APInt(32, "-10", 8)); 1205 EXPECT_EQ(APInt(32, uint32_t(-15LL)), APInt(32, "-17", 8)); 1206 EXPECT_EQ(APInt(32, uint32_t(-16LL)), APInt(32, "-20", 8)); 1207 1208 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 10)); 1209 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 10)); 1210 EXPECT_EQ(APInt(32, 9), APInt(32, "9", 10)); 1211 EXPECT_EQ(APInt(32, 10), APInt(32, "10", 10)); 1212 EXPECT_EQ(APInt(32, 19), APInt(32, "19", 10)); 1213 EXPECT_EQ(APInt(32, 20), APInt(32, "20", 10)); 1214 1215 EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 10)); 1216 EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 10)); 1217 EXPECT_EQ(APInt(32, uint32_t(-9LL)), APInt(32, "-9", 10)); 1218 EXPECT_EQ(APInt(32, uint32_t(-10LL)), APInt(32, "-10", 10)); 1219 EXPECT_EQ(APInt(32, uint32_t(-19LL)), APInt(32, "-19", 10)); 1220 EXPECT_EQ(APInt(32, uint32_t(-20LL)), APInt(32, "-20", 10)); 1221 1222 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 16)); 1223 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 16)); 1224 EXPECT_EQ(APInt(32, 15), APInt(32, "F", 16)); 1225 EXPECT_EQ(APInt(32, 16), APInt(32, "10", 16)); 1226 EXPECT_EQ(APInt(32, 31), APInt(32, "1F", 16)); 1227 EXPECT_EQ(APInt(32, 32), APInt(32, "20", 16)); 1228 1229 EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 16)); 1230 EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 16)); 1231 EXPECT_EQ(APInt(32, uint32_t(-15LL)), APInt(32, "-F", 16)); 1232 EXPECT_EQ(APInt(32, uint32_t(-16LL)), APInt(32, "-10", 16)); 1233 EXPECT_EQ(APInt(32, uint32_t(-31LL)), APInt(32, "-1F", 16)); 1234 EXPECT_EQ(APInt(32, uint32_t(-32LL)), APInt(32, "-20", 16)); 1235 1236 EXPECT_EQ(APInt(32, 0), APInt(32, "0", 36)); 1237 EXPECT_EQ(APInt(32, 1), APInt(32, "1", 36)); 1238 EXPECT_EQ(APInt(32, 35), APInt(32, "Z", 36)); 1239 EXPECT_EQ(APInt(32, 36), APInt(32, "10", 36)); 1240 EXPECT_EQ(APInt(32, 71), APInt(32, "1Z", 36)); 1241 EXPECT_EQ(APInt(32, 72), APInt(32, "20", 36)); 1242 1243 EXPECT_EQ(APInt(32, uint32_t(-0LL)), APInt(32, "-0", 36)); 1244 EXPECT_EQ(APInt(32, uint32_t(-1LL)), APInt(32, "-1", 36)); 1245 EXPECT_EQ(APInt(32, uint32_t(-35LL)), APInt(32, "-Z", 36)); 1246 EXPECT_EQ(APInt(32, uint32_t(-36LL)), APInt(32, "-10", 36)); 1247 EXPECT_EQ(APInt(32, uint32_t(-71LL)), APInt(32, "-1Z", 36)); 1248 EXPECT_EQ(APInt(32, uint32_t(-72LL)), APInt(32, "-20", 36)); 1249 } 1250 1251 TEST(APIntTest, SaturatingMath) { 1252 APInt AP_10 = APInt(8, 10); 1253 APInt AP_42 = APInt(8, 42); 1254 APInt AP_100 = APInt(8, 100); 1255 APInt AP_200 = APInt(8, 200); 1256 1257 EXPECT_EQ(APInt(8, 100), AP_100.truncUSat(8)); 1258 EXPECT_EQ(APInt(7, 100), AP_100.truncUSat(7)); 1259 EXPECT_EQ(APInt(6, 63), AP_100.truncUSat(6)); 1260 EXPECT_EQ(APInt(5, 31), AP_100.truncUSat(5)); 1261 1262 EXPECT_EQ(APInt(8, 200), AP_200.truncUSat(8)); 1263 EXPECT_EQ(APInt(7, 127), AP_200.truncUSat(7)); 1264 EXPECT_EQ(APInt(6, 63), AP_200.truncUSat(6)); 1265 EXPECT_EQ(APInt(5, 31), AP_200.truncUSat(5)); 1266 1267 EXPECT_EQ(APInt(8, 42), AP_42.truncSSat(8)); 1268 EXPECT_EQ(APInt(7, 42), AP_42.truncSSat(7)); 1269 EXPECT_EQ(APInt(6, 31), AP_42.truncSSat(6)); 1270 EXPECT_EQ(APInt(5, 15), AP_42.truncSSat(5)); 1271 1272 EXPECT_EQ(APInt(8, -56, true), AP_200.truncSSat(8)); 1273 EXPECT_EQ(APInt(7, -56, true), AP_200.truncSSat(7)); 1274 EXPECT_EQ(APInt(6, -32, true), AP_200.truncSSat(6)); 1275 EXPECT_EQ(APInt(5, -16, true), AP_200.truncSSat(5)); 1276 1277 EXPECT_EQ(APInt(8, 200), AP_100.uadd_sat(AP_100)); 1278 EXPECT_EQ(APInt(8, 255), AP_100.uadd_sat(AP_200)); 1279 EXPECT_EQ(APInt(8, 255), APInt(8, 255).uadd_sat(APInt(8, 255))); 1280 1281 EXPECT_EQ(APInt(8, 110), AP_10.sadd_sat(AP_100)); 1282 EXPECT_EQ(APInt(8, 127), AP_100.sadd_sat(AP_100)); 1283 EXPECT_EQ(APInt(8, -128, true), (-AP_100).sadd_sat(-AP_100)); 1284 EXPECT_EQ(APInt(8, -128, true), 1285 APInt(8, -128, true).sadd_sat(APInt(8, -128, true))); 1286 1287 EXPECT_EQ(APInt(8, 90), AP_100.usub_sat(AP_10)); 1288 EXPECT_EQ(APInt(8, 0), AP_100.usub_sat(AP_200)); 1289 EXPECT_EQ(APInt(8, 0), APInt(8, 0).usub_sat(APInt(8, 255))); 1290 1291 EXPECT_EQ(APInt(8, -90, true), AP_10.ssub_sat(AP_100)); 1292 EXPECT_EQ(APInt(8, 127), AP_100.ssub_sat(-AP_100)); 1293 EXPECT_EQ(APInt(8, -128, true), (-AP_100).ssub_sat(AP_100)); 1294 EXPECT_EQ(APInt(8, -128, true), APInt(8, -128, true).ssub_sat(APInt(8, 127))); 1295 1296 EXPECT_EQ(APInt(8, 250), APInt(8, 50).umul_sat(APInt(8, 5))); 1297 EXPECT_EQ(APInt(8, 255), APInt(8, 50).umul_sat(APInt(8, 6))); 1298 EXPECT_EQ(APInt(8, 255), APInt(8, -128, true).umul_sat(APInt(8, 3))); 1299 EXPECT_EQ(APInt(8, 255), APInt(8, 3).umul_sat(APInt(8, -128, true))); 1300 EXPECT_EQ(APInt(8, 255), APInt(8, -128, true).umul_sat(APInt(8, -128, true))); 1301 1302 EXPECT_EQ(APInt(8, 125), APInt(8, 25).smul_sat(APInt(8, 5))); 1303 EXPECT_EQ(APInt(8, 127), APInt(8, 25).smul_sat(APInt(8, 6))); 1304 EXPECT_EQ(APInt(8, 127), APInt(8, 127).smul_sat(APInt(8, 127))); 1305 EXPECT_EQ(APInt(8, -125, true), APInt(8, -25, true).smul_sat(APInt(8, 5))); 1306 EXPECT_EQ(APInt(8, -125, true), APInt(8, 25).smul_sat(APInt(8, -5, true))); 1307 EXPECT_EQ(APInt(8, 125), APInt(8, -25, true).smul_sat(APInt(8, -5, true))); 1308 EXPECT_EQ(APInt(8, 125), APInt(8, 25).smul_sat(APInt(8, 5))); 1309 EXPECT_EQ(APInt(8, -128, true), APInt(8, -25, true).smul_sat(APInt(8, 6))); 1310 EXPECT_EQ(APInt(8, -128, true), APInt(8, 25).smul_sat(APInt(8, -6, true))); 1311 EXPECT_EQ(APInt(8, 127), APInt(8, -25, true).smul_sat(APInt(8, -6, true))); 1312 EXPECT_EQ(APInt(8, 127), APInt(8, 25).smul_sat(APInt(8, 6))); 1313 1314 EXPECT_EQ(APInt(8, 128), APInt(8, 4).ushl_sat(APInt(8, 5))); 1315 EXPECT_EQ(APInt(8, 255), APInt(8, 4).ushl_sat(APInt(8, 6))); 1316 EXPECT_EQ(APInt(8, 128), APInt(8, 1).ushl_sat(APInt(8, 7))); 1317 EXPECT_EQ(APInt(8, 255), APInt(8, 1).ushl_sat(APInt(8, 8))); 1318 EXPECT_EQ(APInt(8, 255), APInt(8, -128, true).ushl_sat(APInt(8, 2))); 1319 EXPECT_EQ(APInt(8, 255), APInt(8, 64).ushl_sat(APInt(8, 2))); 1320 EXPECT_EQ(APInt(8, 255), APInt(8, 64).ushl_sat(APInt(8, -2, true))); 1321 1322 EXPECT_EQ(APInt(8, 64), APInt(8, 4).sshl_sat(APInt(8, 4))); 1323 EXPECT_EQ(APInt(8, 127), APInt(8, 4).sshl_sat(APInt(8, 5))); 1324 EXPECT_EQ(APInt(8, 127), APInt(8, 1).sshl_sat(APInt(8, 8))); 1325 EXPECT_EQ(APInt(8, -64, true), APInt(8, -4, true).sshl_sat(APInt(8, 4))); 1326 EXPECT_EQ(APInt(8, -128, true), APInt(8, -4, true).sshl_sat(APInt(8, 5))); 1327 EXPECT_EQ(APInt(8, -128, true), APInt(8, -4, true).sshl_sat(APInt(8, 6))); 1328 EXPECT_EQ(APInt(8, -128, true), APInt(8, -1, true).sshl_sat(APInt(8, 7))); 1329 EXPECT_EQ(APInt(8, -128, true), APInt(8, -1, true).sshl_sat(APInt(8, 8))); 1330 } 1331 1332 TEST(APIntTest, FromArray) { 1333 EXPECT_EQ(APInt(32, uint64_t(1)), APInt(32, ArrayRef<uint64_t>(1))); 1334 } 1335 1336 TEST(APIntTest, StringBitsNeeded2) { 1337 EXPECT_EQ(1U, APInt::getBitsNeeded( "0", 2)); 1338 EXPECT_EQ(1U, APInt::getBitsNeeded( "1", 2)); 1339 EXPECT_EQ(2U, APInt::getBitsNeeded( "10", 2)); 1340 EXPECT_EQ(2U, APInt::getBitsNeeded( "11", 2)); 1341 EXPECT_EQ(3U, APInt::getBitsNeeded("100", 2)); 1342 1343 EXPECT_EQ(1U, APInt::getBitsNeeded( "+0", 2)); 1344 EXPECT_EQ(1U, APInt::getBitsNeeded( "+1", 2)); 1345 EXPECT_EQ(2U, APInt::getBitsNeeded( "+10", 2)); 1346 EXPECT_EQ(2U, APInt::getBitsNeeded( "+11", 2)); 1347 EXPECT_EQ(3U, APInt::getBitsNeeded("+100", 2)); 1348 1349 EXPECT_EQ(2U, APInt::getBitsNeeded( "-0", 2)); 1350 EXPECT_EQ(2U, APInt::getBitsNeeded( "-1", 2)); 1351 EXPECT_EQ(3U, APInt::getBitsNeeded( "-10", 2)); 1352 EXPECT_EQ(3U, APInt::getBitsNeeded( "-11", 2)); 1353 EXPECT_EQ(4U, APInt::getBitsNeeded("-100", 2)); 1354 } 1355 1356 TEST(APIntTest, StringBitsNeeded8) { 1357 EXPECT_EQ(3U, APInt::getBitsNeeded( "0", 8)); 1358 EXPECT_EQ(3U, APInt::getBitsNeeded( "7", 8)); 1359 EXPECT_EQ(6U, APInt::getBitsNeeded("10", 8)); 1360 EXPECT_EQ(6U, APInt::getBitsNeeded("17", 8)); 1361 EXPECT_EQ(6U, APInt::getBitsNeeded("20", 8)); 1362 1363 EXPECT_EQ(3U, APInt::getBitsNeeded( "+0", 8)); 1364 EXPECT_EQ(3U, APInt::getBitsNeeded( "+7", 8)); 1365 EXPECT_EQ(6U, APInt::getBitsNeeded("+10", 8)); 1366 EXPECT_EQ(6U, APInt::getBitsNeeded("+17", 8)); 1367 EXPECT_EQ(6U, APInt::getBitsNeeded("+20", 8)); 1368 1369 EXPECT_EQ(4U, APInt::getBitsNeeded( "-0", 8)); 1370 EXPECT_EQ(4U, APInt::getBitsNeeded( "-7", 8)); 1371 EXPECT_EQ(7U, APInt::getBitsNeeded("-10", 8)); 1372 EXPECT_EQ(7U, APInt::getBitsNeeded("-17", 8)); 1373 EXPECT_EQ(7U, APInt::getBitsNeeded("-20", 8)); 1374 } 1375 1376 TEST(APIntTest, StringBitsNeeded10) { 1377 EXPECT_EQ(1U, APInt::getBitsNeeded( "0", 10)); 1378 EXPECT_EQ(2U, APInt::getBitsNeeded( "3", 10)); 1379 EXPECT_EQ(4U, APInt::getBitsNeeded( "9", 10)); 1380 EXPECT_EQ(4U, APInt::getBitsNeeded("10", 10)); 1381 EXPECT_EQ(5U, APInt::getBitsNeeded("19", 10)); 1382 EXPECT_EQ(5U, APInt::getBitsNeeded("20", 10)); 1383 1384 EXPECT_EQ(1U, APInt::getBitsNeeded( "+0", 10)); 1385 EXPECT_EQ(4U, APInt::getBitsNeeded( "+9", 10)); 1386 EXPECT_EQ(4U, APInt::getBitsNeeded("+10", 10)); 1387 EXPECT_EQ(5U, APInt::getBitsNeeded("+19", 10)); 1388 EXPECT_EQ(5U, APInt::getBitsNeeded("+20", 10)); 1389 1390 EXPECT_EQ(2U, APInt::getBitsNeeded( "-0", 10)); 1391 EXPECT_EQ(5U, APInt::getBitsNeeded( "-9", 10)); 1392 EXPECT_EQ(5U, APInt::getBitsNeeded("-10", 10)); 1393 EXPECT_EQ(6U, APInt::getBitsNeeded("-19", 10)); 1394 EXPECT_EQ(6U, APInt::getBitsNeeded("-20", 10)); 1395 1396 EXPECT_EQ(1U, APInt::getBitsNeeded("-1", 10)); 1397 EXPECT_EQ(2U, APInt::getBitsNeeded("-2", 10)); 1398 EXPECT_EQ(3U, APInt::getBitsNeeded("-4", 10)); 1399 EXPECT_EQ(4U, APInt::getBitsNeeded("-8", 10)); 1400 EXPECT_EQ(5U, APInt::getBitsNeeded("-16", 10)); 1401 EXPECT_EQ(6U, APInt::getBitsNeeded("-23", 10)); 1402 EXPECT_EQ(6U, APInt::getBitsNeeded("-32", 10)); 1403 EXPECT_EQ(7U, APInt::getBitsNeeded("-64", 10)); 1404 EXPECT_EQ(8U, APInt::getBitsNeeded("-127", 10)); 1405 EXPECT_EQ(8U, APInt::getBitsNeeded("-128", 10)); 1406 EXPECT_EQ(9U, APInt::getBitsNeeded("-255", 10)); 1407 EXPECT_EQ(9U, APInt::getBitsNeeded("-256", 10)); 1408 EXPECT_EQ(10U, APInt::getBitsNeeded("-512", 10)); 1409 EXPECT_EQ(11U, APInt::getBitsNeeded("-1024", 10)); 1410 EXPECT_EQ(12U, APInt::getBitsNeeded("-1025", 10)); 1411 } 1412 1413 TEST(APIntTest, StringBitsNeeded16) { 1414 EXPECT_EQ(4U, APInt::getBitsNeeded( "0", 16)); 1415 EXPECT_EQ(4U, APInt::getBitsNeeded( "F", 16)); 1416 EXPECT_EQ(8U, APInt::getBitsNeeded("10", 16)); 1417 EXPECT_EQ(8U, APInt::getBitsNeeded("1F", 16)); 1418 EXPECT_EQ(8U, APInt::getBitsNeeded("20", 16)); 1419 1420 EXPECT_EQ(4U, APInt::getBitsNeeded( "+0", 16)); 1421 EXPECT_EQ(4U, APInt::getBitsNeeded( "+F", 16)); 1422 EXPECT_EQ(8U, APInt::getBitsNeeded("+10", 16)); 1423 EXPECT_EQ(8U, APInt::getBitsNeeded("+1F", 16)); 1424 EXPECT_EQ(8U, APInt::getBitsNeeded("+20", 16)); 1425 1426 EXPECT_EQ(5U, APInt::getBitsNeeded( "-0", 16)); 1427 EXPECT_EQ(5U, APInt::getBitsNeeded( "-F", 16)); 1428 EXPECT_EQ(9U, APInt::getBitsNeeded("-10", 16)); 1429 EXPECT_EQ(9U, APInt::getBitsNeeded("-1F", 16)); 1430 EXPECT_EQ(9U, APInt::getBitsNeeded("-20", 16)); 1431 } 1432 1433 TEST(APIntTest, toString) { 1434 SmallString<16> S; 1435 bool isSigned; 1436 1437 APInt(8, 0).toString(S, 2, true, true); 1438 EXPECT_EQ(std::string(S), "0b0"); 1439 S.clear(); 1440 APInt(8, 0).toString(S, 8, true, true); 1441 EXPECT_EQ(std::string(S), "00"); 1442 S.clear(); 1443 APInt(8, 0).toString(S, 10, true, true); 1444 EXPECT_EQ(std::string(S), "0"); 1445 S.clear(); 1446 APInt(8, 0).toString(S, 16, true, true); 1447 EXPECT_EQ(std::string(S), "0x0"); 1448 S.clear(); 1449 APInt(8, 0).toString(S, 36, true, false); 1450 EXPECT_EQ(std::string(S), "0"); 1451 S.clear(); 1452 1453 // with separators 1454 APInt(64, 140).toString(S, 2, false, true, false, true); 1455 EXPECT_EQ(std::string(S), "0b1000'1100"); 1456 S.clear(); 1457 APInt(64, 1024).toString(S, 8, false, true, false, true); 1458 EXPECT_EQ(std::string(S), "02'000"); 1459 S.clear(); 1460 APInt(64, 1000000).toString(S, 10, false, true, false, true); 1461 EXPECT_EQ(std::string(S), "1'000'000"); 1462 S.clear(); 1463 APInt(64, 1000000).toString(S, 16, false, true, true, true); 1464 EXPECT_EQ(std::string(S), "0xF'4240"); 1465 S.clear(); 1466 APInt(64, 1'000'000'000).toString(S, 36, false, false, false, true); 1467 EXPECT_EQ(std::string(S), "gj'dgxs"); 1468 S.clear(); 1469 1470 isSigned = false; 1471 APInt(8, 255).toString(S, 2, isSigned, true); 1472 EXPECT_EQ(std::string(S), "0b11111111"); 1473 S.clear(); 1474 APInt(8, 255).toString(S, 8, isSigned, true); 1475 EXPECT_EQ(std::string(S), "0377"); 1476 S.clear(); 1477 APInt(8, 255).toString(S, 10, isSigned, true); 1478 EXPECT_EQ(std::string(S), "255"); 1479 S.clear(); 1480 APInt(8, 255).toString(S, 16, isSigned, true, /*UpperCase=*/false); 1481 EXPECT_EQ(std::string(S), "0xff"); 1482 S.clear(); 1483 APInt(8, 255).toString(S, 16, isSigned, true); 1484 EXPECT_EQ(std::string(S), "0xFF"); 1485 S.clear(); 1486 APInt(8, 255).toString(S, 36, isSigned, false); 1487 EXPECT_EQ(std::string(S), "73"); 1488 S.clear(); 1489 1490 isSigned = true; 1491 APInt(8, 255).toString(S, 2, isSigned, true); 1492 EXPECT_EQ(std::string(S), "-0b1"); 1493 S.clear(); 1494 APInt(8, 255).toString(S, 8, isSigned, true); 1495 EXPECT_EQ(std::string(S), "-01"); 1496 S.clear(); 1497 APInt(8, 255).toString(S, 10, isSigned, true); 1498 EXPECT_EQ(std::string(S), "-1"); 1499 S.clear(); 1500 APInt(8, 255).toString(S, 16, isSigned, true); 1501 EXPECT_EQ(std::string(S), "-0x1"); 1502 S.clear(); 1503 APInt(8, 255).toString(S, 36, isSigned, false); 1504 EXPECT_EQ(std::string(S), "-1"); 1505 S.clear(); 1506 1507 // negative with separators 1508 APInt(64, -140, isSigned).toString(S, 2, isSigned, true, false, true); 1509 EXPECT_EQ(std::string(S), "-0b1000'1100"); 1510 S.clear(); 1511 APInt(64, -1024, isSigned).toString(S, 8, isSigned, true, false, true); 1512 EXPECT_EQ(std::string(S), "-02'000"); 1513 S.clear(); 1514 APInt(64, -1000000, isSigned).toString(S, 10, isSigned, true, false, true); 1515 EXPECT_EQ(std::string(S), "-1'000'000"); 1516 S.clear(); 1517 APInt(64, -1000000, isSigned).toString(S, 16, isSigned, true, true, true); 1518 EXPECT_EQ(std::string(S), "-0xF'4240"); 1519 S.clear(); 1520 APInt(64, -1'000'000'000, isSigned) 1521 .toString(S, 36, isSigned, false, false, true); 1522 EXPECT_EQ(std::string(S), "-gj'dgxs"); 1523 S.clear(); 1524 } 1525 1526 TEST(APIntTest, Log2) { 1527 EXPECT_EQ(APInt(15, 7).logBase2(), 2U); 1528 EXPECT_EQ(APInt(15, 7).ceilLogBase2(), 3U); 1529 EXPECT_EQ(APInt(15, 7).exactLogBase2(), -1); 1530 EXPECT_EQ(APInt(15, 8).logBase2(), 3U); 1531 EXPECT_EQ(APInt(15, 8).ceilLogBase2(), 3U); 1532 EXPECT_EQ(APInt(15, 8).exactLogBase2(), 3); 1533 EXPECT_EQ(APInt(15, 9).logBase2(), 3U); 1534 EXPECT_EQ(APInt(15, 9).ceilLogBase2(), 4U); 1535 EXPECT_EQ(APInt(15, 9).exactLogBase2(), -1); 1536 } 1537 1538 #ifdef GTEST_HAS_DEATH_TEST 1539 #ifndef NDEBUG 1540 TEST(APIntTest, StringDeath) { 1541 EXPECT_DEATH((void)APInt(32, "", 0), "Invalid string length"); 1542 EXPECT_DEATH((void)APInt(32, "0", 0), "Radix should be 2, 8, 10, 16, or 36!"); 1543 EXPECT_DEATH((void)APInt(32, "", 10), "Invalid string length"); 1544 EXPECT_DEATH((void)APInt(32, "-", 10), "String is only a sign, needs a value."); 1545 EXPECT_DEATH((void)APInt(1, "1234", 10), "Insufficient bit width"); 1546 EXPECT_DEATH((void)APInt(32, "\0", 10), "Invalid string length"); 1547 EXPECT_DEATH((void)APInt(32, StringRef("1\02", 3), 10), "Invalid character in digit string"); 1548 EXPECT_DEATH((void)APInt(32, "1L", 10), "Invalid character in digit string"); 1549 } 1550 #endif 1551 #endif 1552 1553 TEST(APIntTest, mul_clear) { 1554 APInt ValA(65, -1ULL); 1555 APInt ValB(65, 4); 1556 APInt ValC(65, 0); 1557 ValC = ValA * ValB; 1558 ValA *= ValB; 1559 SmallString<16> StrA, StrC; 1560 ValA.toString(StrA, 10, false); 1561 ValC.toString(StrC, 10, false); 1562 EXPECT_EQ(std::string(StrA), std::string(StrC)); 1563 } 1564 1565 TEST(APIntTest, Rotate) { 1566 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotl(0)); 1567 EXPECT_EQ(APInt(8, 2), APInt(8, 1).rotl(1)); 1568 EXPECT_EQ(APInt(8, 4), APInt(8, 1).rotl(2)); 1569 EXPECT_EQ(APInt(8, 16), APInt(8, 1).rotl(4)); 1570 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotl(8)); 1571 1572 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotl(0)); 1573 EXPECT_EQ(APInt(8, 32), APInt(8, 16).rotl(1)); 1574 EXPECT_EQ(APInt(8, 64), APInt(8, 16).rotl(2)); 1575 EXPECT_EQ(APInt(8, 1), APInt(8, 16).rotl(4)); 1576 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotl(8)); 1577 1578 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(33)); 1579 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(32, 33))); 1580 1581 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(33)); 1582 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(32, 33))); 1583 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(33, 33))); 1584 EXPECT_EQ(APInt(32, (1 << 8)), APInt(32, 1).rotl(APInt(32, 40))); 1585 EXPECT_EQ(APInt(32, (1 << 30)), APInt(32, 1).rotl(APInt(31, 30))); 1586 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotl(APInt(31, 31))); 1587 1588 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotl(APInt(1, 0))); 1589 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(1, 1))); 1590 1591 EXPECT_EQ(APInt(32, 16), APInt(32, 1).rotl(APInt(3, 4))); 1592 1593 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotl(APInt(64, 64))); 1594 EXPECT_EQ(APInt(32, 2), APInt(32, 1).rotl(APInt(64, 65))); 1595 1596 EXPECT_EQ(APInt(7, 24), APInt(7, 3).rotl(APInt(7, 3))); 1597 EXPECT_EQ(APInt(7, 24), APInt(7, 3).rotl(APInt(7, 10))); 1598 EXPECT_EQ(APInt(7, 24), APInt(7, 3).rotl(APInt(5, 10))); 1599 EXPECT_EQ(APInt(7, 6), APInt(7, 3).rotl(APInt(12, 120))); 1600 1601 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotr(0)); 1602 EXPECT_EQ(APInt(8, 8), APInt(8, 16).rotr(1)); 1603 EXPECT_EQ(APInt(8, 4), APInt(8, 16).rotr(2)); 1604 EXPECT_EQ(APInt(8, 1), APInt(8, 16).rotr(4)); 1605 EXPECT_EQ(APInt(8, 16), APInt(8, 16).rotr(8)); 1606 1607 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotr(0)); 1608 EXPECT_EQ(APInt(8, 128), APInt(8, 1).rotr(1)); 1609 EXPECT_EQ(APInt(8, 64), APInt(8, 1).rotr(2)); 1610 EXPECT_EQ(APInt(8, 16), APInt(8, 1).rotr(4)); 1611 EXPECT_EQ(APInt(8, 1), APInt(8, 1).rotr(8)); 1612 1613 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(33)); 1614 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(32, 33))); 1615 1616 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(33)); 1617 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(32, 33))); 1618 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(33, 33))); 1619 EXPECT_EQ(APInt(32, (1 << 24)), APInt(32, 1).rotr(APInt(32, 40))); 1620 1621 EXPECT_EQ(APInt(32, (1 << 2)), APInt(32, 1).rotr(APInt(31, 30))); 1622 EXPECT_EQ(APInt(32, (1 << 1)), APInt(32, 1).rotr(APInt(31, 31))); 1623 1624 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotr(APInt(1, 0))); 1625 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(1, 1))); 1626 1627 EXPECT_EQ(APInt(32, (1 << 28)), APInt(32, 1).rotr(APInt(3, 4))); 1628 1629 EXPECT_EQ(APInt(32, 1), APInt(32, 1).rotr(APInt(64, 64))); 1630 EXPECT_EQ(APInt(32, (1u << 31)), APInt(32, 1).rotr(APInt(64, 65))); 1631 1632 EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(7, 3))); 1633 EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(7, 10))); 1634 EXPECT_EQ(APInt(7, 48), APInt(7, 3).rotr(APInt(5, 10))); 1635 EXPECT_EQ(APInt(7, 65), APInt(7, 3).rotr(APInt(12, 120))); 1636 1637 APInt Big(256, "00004000800000000000000000003fff8000000000000003", 16); 1638 APInt Rot(256, "3fff80000000000000030000000000000000000040008000", 16); 1639 EXPECT_EQ(Rot, Big.rotr(144)); 1640 1641 EXPECT_EQ(APInt(32, 8), APInt(32, 1).rotl(Big)); 1642 EXPECT_EQ(APInt(32, (1 << 29)), APInt(32, 1).rotr(Big)); 1643 } 1644 1645 TEST(APIntTest, Splat) { 1646 APInt ValA(8, 0x01); 1647 EXPECT_EQ(ValA, APInt::getSplat(8, ValA)); 1648 EXPECT_EQ(APInt(64, 0x0101010101010101ULL), APInt::getSplat(64, ValA)); 1649 1650 APInt ValB(3, 5); 1651 EXPECT_EQ(APInt(4, 0xD), APInt::getSplat(4, ValB)); 1652 EXPECT_EQ(APInt(15, 0x5B6D), APInt::getSplat(15, ValB)); 1653 } 1654 1655 TEST(APIntTest, tcDecrement) { 1656 // Test single word decrement. 1657 1658 // No out borrow. 1659 { 1660 APInt::WordType singleWord = ~APInt::WordType(0) << (APInt::APINT_BITS_PER_WORD - 1); 1661 APInt::WordType carry = APInt::tcDecrement(&singleWord, 1); 1662 EXPECT_EQ(carry, APInt::WordType(0)); 1663 EXPECT_EQ(singleWord, ~APInt::WordType(0) >> 1); 1664 } 1665 1666 // With out borrow. 1667 { 1668 APInt::WordType singleWord = 0; 1669 APInt::WordType carry = APInt::tcDecrement(&singleWord, 1); 1670 EXPECT_EQ(carry, APInt::WordType(1)); 1671 EXPECT_EQ(singleWord, ~APInt::WordType(0)); 1672 } 1673 1674 // Test multiword decrement. 1675 1676 // No across word borrow, no out borrow. 1677 { 1678 APInt::WordType test[4] = {0x1, 0x1, 0x1, 0x1}; 1679 APInt::WordType expected[4] = {0x0, 0x1, 0x1, 0x1}; 1680 APInt::tcDecrement(test, 4); 1681 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0); 1682 } 1683 1684 // 1 across word borrow, no out borrow. 1685 { 1686 APInt::WordType test[4] = {0x0, 0xF, 0x1, 0x1}; 1687 APInt::WordType expected[4] = {~APInt::WordType(0), 0xE, 0x1, 0x1}; 1688 APInt::WordType carry = APInt::tcDecrement(test, 4); 1689 EXPECT_EQ(carry, APInt::WordType(0)); 1690 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0); 1691 } 1692 1693 // 2 across word borrow, no out borrow. 1694 { 1695 APInt::WordType test[4] = {0x0, 0x0, 0xC, 0x1}; 1696 APInt::WordType expected[4] = {~APInt::WordType(0), ~APInt::WordType(0), 0xB, 0x1}; 1697 APInt::WordType carry = APInt::tcDecrement(test, 4); 1698 EXPECT_EQ(carry, APInt::WordType(0)); 1699 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0); 1700 } 1701 1702 // 3 across word borrow, no out borrow. 1703 { 1704 APInt::WordType test[4] = {0x0, 0x0, 0x0, 0x1}; 1705 APInt::WordType expected[4] = {~APInt::WordType(0), ~APInt::WordType(0), ~APInt::WordType(0), 0x0}; 1706 APInt::WordType carry = APInt::tcDecrement(test, 4); 1707 EXPECT_EQ(carry, APInt::WordType(0)); 1708 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0); 1709 } 1710 1711 // 3 across word borrow, with out borrow. 1712 { 1713 APInt::WordType test[4] = {0x0, 0x0, 0x0, 0x0}; 1714 APInt::WordType expected[4] = {~APInt::WordType(0), ~APInt::WordType(0), ~APInt::WordType(0), ~APInt::WordType(0)}; 1715 APInt::WordType carry = APInt::tcDecrement(test, 4); 1716 EXPECT_EQ(carry, APInt::WordType(1)); 1717 EXPECT_EQ(APInt::tcCompare(test, expected, 4), 0); 1718 } 1719 } 1720 1721 TEST(APIntTest, arrayAccess) { 1722 // Single word check. 1723 uint64_t E1 = 0x2CA7F46BF6569915ULL; 1724 APInt A1(64, E1); 1725 for (unsigned i = 0, e = 64; i < e; ++i) { 1726 EXPECT_EQ(bool(E1 & (1ULL << i)), 1727 A1[i]); 1728 } 1729 1730 // Multiword check. 1731 APInt::WordType E2[4] = { 1732 0xEB6EB136591CBA21ULL, 1733 0x7B9358BD6A33F10AULL, 1734 0x7E7FFA5EADD8846ULL, 1735 0x305F341CA00B613DULL 1736 }; 1737 APInt A2(APInt::APINT_BITS_PER_WORD*4, E2); 1738 for (unsigned i = 0; i < 4; ++i) { 1739 for (unsigned j = 0; j < APInt::APINT_BITS_PER_WORD; ++j) { 1740 EXPECT_EQ(bool(E2[i] & (1ULL << j)), 1741 A2[i*APInt::APINT_BITS_PER_WORD + j]); 1742 } 1743 } 1744 } 1745 1746 TEST(APIntTest, LargeAPIntConstruction) { 1747 // Check that we can properly construct very large APInt. It is very 1748 // unlikely that people will ever do this, but it is a legal input, 1749 // so we should not crash on it. 1750 APInt A9(UINT32_MAX, 0); 1751 EXPECT_FALSE(A9.getBoolValue()); 1752 } 1753 1754 TEST(APIntTest, nearestLogBase2) { 1755 // Single word check. 1756 1757 // Test round up. 1758 uint64_t I1 = 0x1800001; 1759 APInt A1(64, I1); 1760 EXPECT_EQ(A1.nearestLogBase2(), A1.ceilLogBase2()); 1761 1762 // Test round down. 1763 uint64_t I2 = 0x1000011; 1764 APInt A2(64, I2); 1765 EXPECT_EQ(A2.nearestLogBase2(), A2.logBase2()); 1766 1767 // Test ties round up. 1768 uint64_t I3 = 0x1800000; 1769 APInt A3(64, I3); 1770 EXPECT_EQ(A3.nearestLogBase2(), A3.ceilLogBase2()); 1771 1772 // Multiple word check. 1773 1774 // Test round up. 1775 APInt::WordType I4[4] = {0x0, 0xF, 0x18, 0x0}; 1776 APInt A4(APInt::APINT_BITS_PER_WORD*4, I4); 1777 EXPECT_EQ(A4.nearestLogBase2(), A4.ceilLogBase2()); 1778 1779 // Test round down. 1780 APInt::WordType I5[4] = {0x0, 0xF, 0x10, 0x0}; 1781 APInt A5(APInt::APINT_BITS_PER_WORD*4, I5); 1782 EXPECT_EQ(A5.nearestLogBase2(), A5.logBase2()); 1783 1784 // Test ties round up. 1785 uint64_t I6[4] = {0x0, 0x0, 0x0, 0x18}; 1786 APInt A6(APInt::APINT_BITS_PER_WORD*4, I6); 1787 EXPECT_EQ(A6.nearestLogBase2(), A6.ceilLogBase2()); 1788 1789 // Test BitWidth == 1 special cases. 1790 APInt A7(1, 1); 1791 EXPECT_EQ(A7.nearestLogBase2(), 0ULL); 1792 APInt A8(1, 0); 1793 EXPECT_EQ(A8.nearestLogBase2(), UINT32_MAX); 1794 1795 // Test the zero case when we have a bit width large enough such 1796 // that the bit width is larger than UINT32_MAX-1. 1797 APInt A9(UINT32_MAX, 0); 1798 EXPECT_EQ(A9.nearestLogBase2(), UINT32_MAX); 1799 } 1800 1801 TEST(APIntTest, IsSplat) { 1802 APInt A(32, 0x01010101); 1803 EXPECT_FALSE(A.isSplat(1)); 1804 EXPECT_FALSE(A.isSplat(2)); 1805 EXPECT_FALSE(A.isSplat(4)); 1806 EXPECT_TRUE(A.isSplat(8)); 1807 EXPECT_TRUE(A.isSplat(16)); 1808 EXPECT_TRUE(A.isSplat(32)); 1809 1810 APInt B(24, 0xAAAAAA); 1811 EXPECT_FALSE(B.isSplat(1)); 1812 EXPECT_TRUE(B.isSplat(2)); 1813 EXPECT_TRUE(B.isSplat(4)); 1814 EXPECT_TRUE(B.isSplat(8)); 1815 EXPECT_TRUE(B.isSplat(24)); 1816 1817 APInt C(24, 0xABAAAB); 1818 EXPECT_FALSE(C.isSplat(1)); 1819 EXPECT_FALSE(C.isSplat(2)); 1820 EXPECT_FALSE(C.isSplat(4)); 1821 EXPECT_FALSE(C.isSplat(8)); 1822 EXPECT_TRUE(C.isSplat(24)); 1823 1824 APInt D(32, 0xABBAABBA); 1825 EXPECT_FALSE(D.isSplat(1)); 1826 EXPECT_FALSE(D.isSplat(2)); 1827 EXPECT_FALSE(D.isSplat(4)); 1828 EXPECT_FALSE(D.isSplat(8)); 1829 EXPECT_TRUE(D.isSplat(16)); 1830 EXPECT_TRUE(D.isSplat(32)); 1831 1832 APInt E(32, 0); 1833 EXPECT_TRUE(E.isSplat(1)); 1834 EXPECT_TRUE(E.isSplat(2)); 1835 EXPECT_TRUE(E.isSplat(4)); 1836 EXPECT_TRUE(E.isSplat(8)); 1837 EXPECT_TRUE(E.isSplat(16)); 1838 EXPECT_TRUE(E.isSplat(32)); 1839 } 1840 1841 TEST(APIntTest, isMask) { 1842 EXPECT_FALSE(APInt(32, 0x01010101).isMask()); 1843 EXPECT_FALSE(APInt(32, 0xf0000000).isMask()); 1844 EXPECT_FALSE(APInt(32, 0xffff0000).isMask()); 1845 EXPECT_FALSE(APInt(32, 0xff << 1).isMask()); 1846 1847 for (int N : { 1, 2, 3, 4, 7, 8, 16, 32, 64, 127, 128, 129, 256 }) { 1848 EXPECT_FALSE(APInt(N, 0).isMask()); 1849 1850 APInt One(N, 1); 1851 for (int I = 1; I <= N; ++I) { 1852 APInt MaskVal = One.shl(I) - 1; 1853 EXPECT_TRUE(MaskVal.isMask()); 1854 EXPECT_TRUE(MaskVal.isMask(I)); 1855 } 1856 } 1857 } 1858 1859 TEST(APIntTest, isShiftedMask) { 1860 EXPECT_FALSE(APInt(32, 0x01010101).isShiftedMask()); 1861 EXPECT_TRUE(APInt(32, 0xf0000000).isShiftedMask()); 1862 EXPECT_TRUE(APInt(32, 0xffff0000).isShiftedMask()); 1863 EXPECT_TRUE(APInt(32, 0xff << 1).isShiftedMask()); 1864 1865 unsigned MaskIdx, MaskLen; 1866 EXPECT_FALSE(APInt(32, 0x01010101).isShiftedMask(MaskIdx, MaskLen)); 1867 EXPECT_TRUE(APInt(32, 0xf0000000).isShiftedMask(MaskIdx, MaskLen)); 1868 EXPECT_EQ(28, (int)MaskIdx); 1869 EXPECT_EQ(4, (int)MaskLen); 1870 EXPECT_TRUE(APInt(32, 0xffff0000).isShiftedMask(MaskIdx, MaskLen)); 1871 EXPECT_EQ(16, (int)MaskIdx); 1872 EXPECT_EQ(16, (int)MaskLen); 1873 EXPECT_TRUE(APInt(32, 0xff << 1).isShiftedMask(MaskIdx, MaskLen)); 1874 EXPECT_EQ(1, (int)MaskIdx); 1875 EXPECT_EQ(8, (int)MaskLen); 1876 1877 for (int N : { 1, 2, 3, 4, 7, 8, 16, 32, 64, 127, 128, 129, 256 }) { 1878 EXPECT_FALSE(APInt(N, 0).isShiftedMask()); 1879 EXPECT_FALSE(APInt(N, 0).isShiftedMask(MaskIdx, MaskLen)); 1880 1881 APInt One(N, 1); 1882 for (int I = 1; I < N; ++I) { 1883 APInt MaskVal = One.shl(I) - 1; 1884 EXPECT_TRUE(MaskVal.isShiftedMask()); 1885 EXPECT_TRUE(MaskVal.isShiftedMask(MaskIdx, MaskLen)); 1886 EXPECT_EQ(0, (int)MaskIdx); 1887 EXPECT_EQ(I, (int)MaskLen); 1888 } 1889 for (int I = 1; I < N - 1; ++I) { 1890 APInt MaskVal = One.shl(I); 1891 EXPECT_TRUE(MaskVal.isShiftedMask()); 1892 EXPECT_TRUE(MaskVal.isShiftedMask(MaskIdx, MaskLen)); 1893 EXPECT_EQ(I, (int)MaskIdx); 1894 EXPECT_EQ(1, (int)MaskLen); 1895 } 1896 for (int I = 1; I < N; ++I) { 1897 APInt MaskVal = APInt::getHighBitsSet(N, I); 1898 EXPECT_TRUE(MaskVal.isShiftedMask()); 1899 EXPECT_TRUE(MaskVal.isShiftedMask(MaskIdx, MaskLen)); 1900 EXPECT_EQ(N - I, (int)MaskIdx); 1901 EXPECT_EQ(I, (int)MaskLen); 1902 } 1903 } 1904 } 1905 1906 TEST(APIntTest, isOneBitSet) { 1907 EXPECT_FALSE(APInt(5, 0x00).isOneBitSet(0)); 1908 EXPECT_FALSE(APInt(5, 0x02).isOneBitSet(0)); 1909 EXPECT_FALSE(APInt(5, 0x03).isOneBitSet(0)); 1910 EXPECT_TRUE(APInt(5, 0x02).isOneBitSet(1)); 1911 EXPECT_TRUE(APInt(32, (unsigned)(0xffu << 31)).isOneBitSet(31)); 1912 1913 EXPECT_TRUE(APInt::getOneBitSet(255, 13).isOneBitSet(13)); 1914 } 1915 1916 TEST(APIntTest, isPowerOf2) { 1917 EXPECT_FALSE(APInt(5, 0x00).isPowerOf2()); 1918 EXPECT_FALSE(APInt(32, 0x11).isPowerOf2()); 1919 EXPECT_TRUE(APInt(17, 0x01).isPowerOf2()); 1920 EXPECT_TRUE(APInt(32, (unsigned)(0xffu << 31)).isPowerOf2()); 1921 1922 for (int N : {1, 2, 3, 4, 7, 8, 16, 32, 64, 127, 128, 129, 256}) { 1923 EXPECT_FALSE(APInt(N, 0).isPowerOf2()); 1924 EXPECT_TRUE(APInt::getSignedMinValue(N).isPowerOf2()); 1925 1926 APInt One(N, 1); 1927 for (int I = 1; I < N - 1; ++I) { 1928 EXPECT_TRUE(APInt::getOneBitSet(N, I).isPowerOf2()); 1929 1930 APInt MaskVal = One.shl(I); 1931 EXPECT_TRUE(MaskVal.isPowerOf2()); 1932 } 1933 } 1934 } 1935 1936 TEST(APIntTest, isNegatedPowerOf2) { 1937 EXPECT_FALSE(APInt(5, 0x00).isNegatedPowerOf2()); 1938 EXPECT_TRUE(APInt(15, 0x7ffe).isNegatedPowerOf2()); 1939 EXPECT_TRUE(APInt(16, 0xfffc).isNegatedPowerOf2()); 1940 EXPECT_TRUE(APInt(32, 0xffffffff).isNegatedPowerOf2()); 1941 1942 for (int N : {1, 2, 3, 4, 7, 8, 16, 32, 64, 127, 128, 129, 256}) { 1943 EXPECT_FALSE(APInt(N, 0).isNegatedPowerOf2()); 1944 EXPECT_TRUE(APInt::getAllOnes(N).isNegatedPowerOf2()); 1945 EXPECT_TRUE(APInt::getSignedMinValue(N).isNegatedPowerOf2()); 1946 EXPECT_TRUE((-APInt::getSignedMinValue(N)).isNegatedPowerOf2()); 1947 1948 APInt One(N, 1); 1949 for (int I = 1; I < N - 1; ++I) { 1950 EXPECT_FALSE(APInt::getOneBitSet(N, I).isNegatedPowerOf2()); 1951 EXPECT_TRUE((-APInt::getOneBitSet(N, I)).isNegatedPowerOf2()); 1952 1953 APInt MaskVal = One.shl(I); 1954 EXPECT_TRUE((-MaskVal).isNegatedPowerOf2()); 1955 1956 APInt ShiftMaskVal = One.getHighBitsSet(N, I); 1957 EXPECT_TRUE(ShiftMaskVal.isNegatedPowerOf2()); 1958 } 1959 } 1960 } 1961 1962 TEST(APIntTest, isAligned) { 1963 struct { 1964 uint64_t alignment; 1965 uint64_t offset; 1966 bool isAligned; 1967 } Tests[] = { 1968 {1, 0, true}, {1, 1, true}, {1, 5, true}, {2, 0, true}, 1969 {2, 1, false}, {2, 2, true}, {2, 7, false}, {2, 16, true}, 1970 {4, 0, true}, {4, 1, false}, {4, 4, true}, {4, 6, false}, 1971 }; 1972 for (const auto &T : Tests) 1973 EXPECT_EQ(APInt(32, T.offset).isAligned(Align(T.alignment)), T.isAligned); 1974 // Tests for APInt that can't represent the alignment. 1975 // Here APInt(4, I) can represent values from 0 to 15. 1976 EXPECT_TRUE(APInt(4, 0).isAligned(Align(32))); // zero is always aligned. 1977 for (int I = 1; I < 16; ++I) 1978 EXPECT_FALSE(APInt(4, I).isAligned(Align(32))); 1979 } 1980 1981 // Test that self-move works with EXPENSIVE_CHECKS. It calls std::shuffle which 1982 // does self-move on some platforms. 1983 #ifdef EXPENSIVE_CHECKS 1984 #if defined(__clang__) 1985 // Disable the pragma warning from versions of Clang without -Wself-move 1986 #pragma clang diagnostic push 1987 #pragma clang diagnostic ignored "-Wunknown-pragmas" 1988 // Disable the warning that triggers on exactly what is being tested. 1989 #pragma clang diagnostic push 1990 #pragma clang diagnostic ignored "-Wself-move" 1991 #endif 1992 TEST(APIntTest, SelfMoveAssignment) { 1993 APInt X(32, 0xdeadbeef); 1994 X = std::move(X); 1995 EXPECT_EQ(32u, X.getBitWidth()); 1996 EXPECT_EQ(0xdeadbeefULL, X.getLimitedValue()); 1997 1998 uint64_t Bits[] = {0xdeadbeefdeadbeefULL, 0xdeadbeefdeadbeefULL}; 1999 APInt Y(128, Bits); 2000 Y = std::move(Y); 2001 EXPECT_EQ(128u, Y.getBitWidth()); 2002 EXPECT_EQ(~0ULL, Y.getLimitedValue()); 2003 const uint64_t *Raw = Y.getRawData(); 2004 EXPECT_EQ(2u, Y.getNumWords()); 2005 EXPECT_EQ(0xdeadbeefdeadbeefULL, Raw[0]); 2006 EXPECT_EQ(0xdeadbeefdeadbeefULL, Raw[1]); 2007 } 2008 #if defined(__clang__) 2009 #pragma clang diagnostic pop 2010 #pragma clang diagnostic pop 2011 #endif 2012 #endif // EXPENSIVE_CHECKS 2013 2014 TEST(APIntTest, byteSwap) { 2015 EXPECT_EQ(0x00000000, APInt(16, 0x0000).byteSwap()); 2016 EXPECT_EQ(0x0000010f, APInt(16, 0x0f01).byteSwap()); 2017 EXPECT_EQ(0x00ff8000, APInt(24, 0x0080ff).byteSwap()); 2018 EXPECT_EQ(0x117700ff, APInt(32, 0xff007711).byteSwap()); 2019 EXPECT_EQ(0x228811aaffULL, APInt(40, 0xffaa118822ULL).byteSwap()); 2020 EXPECT_EQ(0x050403020100ULL, APInt(48, 0x000102030405ULL).byteSwap()); 2021 EXPECT_EQ(0xff050403020100ULL, APInt(56, 0x000102030405ffULL).byteSwap()); 2022 EXPECT_EQ(0xff050403020100aaULL, APInt(64, 0xaa000102030405ffULL).byteSwap()); 2023 2024 for (unsigned N : {16, 24, 32, 48, 56, 64, 72, 80, 96, 112, 128, 248, 256, 2025 1024, 1032, 1040}) { 2026 for (unsigned I = 0; I < N; I += 8) { 2027 APInt X = APInt::getBitsSet(N, I, I + 8); 2028 APInt Y = APInt::getBitsSet(N, N - I - 8, N - I); 2029 EXPECT_EQ(Y, X.byteSwap()); 2030 EXPECT_EQ(X, Y.byteSwap()); 2031 } 2032 } 2033 } 2034 2035 TEST(APIntTest, reverseBits) { 2036 EXPECT_EQ(1, APInt(1, 1).reverseBits()); 2037 EXPECT_EQ(0, APInt(1, 0).reverseBits()); 2038 2039 EXPECT_EQ(3, APInt(2, 3).reverseBits()); 2040 EXPECT_EQ(3, APInt(2, 3).reverseBits()); 2041 2042 EXPECT_EQ(0xb, APInt(4, 0xd).reverseBits()); 2043 EXPECT_EQ(0xd, APInt(4, 0xb).reverseBits()); 2044 EXPECT_EQ(0xf, APInt(4, 0xf).reverseBits()); 2045 2046 EXPECT_EQ(0x30, APInt(7, 0x6).reverseBits()); 2047 EXPECT_EQ(0x5a, APInt(7, 0x2d).reverseBits()); 2048 2049 EXPECT_EQ(0x0f, APInt(8, 0xf0).reverseBits()); 2050 EXPECT_EQ(0xf0, APInt(8, 0x0f).reverseBits()); 2051 2052 EXPECT_EQ(0x0f0f, APInt(16, 0xf0f0).reverseBits()); 2053 EXPECT_EQ(0xf0f0, APInt(16, 0x0f0f).reverseBits()); 2054 2055 EXPECT_EQ(0x0f0f0f0f, APInt(32, 0xf0f0f0f0).reverseBits()); 2056 EXPECT_EQ(0xf0f0f0f0, APInt(32, 0x0f0f0f0f).reverseBits()); 2057 2058 EXPECT_EQ(0x402880a0 >> 1, APInt(31, 0x05011402).reverseBits()); 2059 2060 EXPECT_EQ(0x0f0f0f0f, APInt(32, 0xf0f0f0f0).reverseBits()); 2061 EXPECT_EQ(0xf0f0f0f0, APInt(32, 0x0f0f0f0f).reverseBits()); 2062 2063 EXPECT_EQ(0x0f0f0f0f0f0f0f0f, APInt(64, 0xf0f0f0f0f0f0f0f0).reverseBits()); 2064 EXPECT_EQ(0xf0f0f0f0f0f0f0f0, APInt(64, 0x0f0f0f0f0f0f0f0f).reverseBits()); 2065 2066 for (unsigned N : { 1, 8, 16, 24, 31, 32, 33, 2067 63, 64, 65, 127, 128, 257, 1024 }) { 2068 for (unsigned I = 0; I < N; ++I) { 2069 APInt X = APInt::getOneBitSet(N, I); 2070 APInt Y = APInt::getOneBitSet(N, N - (I + 1)); 2071 EXPECT_EQ(Y, X.reverseBits()); 2072 EXPECT_EQ(X, Y.reverseBits()); 2073 } 2074 } 2075 } 2076 2077 TEST(APIntTest, insertBits) { 2078 APInt iSrc(31, 0x00123456); 2079 2080 // Direct copy. 2081 APInt i31(31, 0x76543210ull); 2082 i31.insertBits(iSrc, 0); 2083 EXPECT_EQ(static_cast<int64_t>(0x00123456ull), i31.getSExtValue()); 2084 2085 // Single word src/dst insertion. 2086 APInt i63(63, 0x01234567FFFFFFFFull); 2087 i63.insertBits(iSrc, 4); 2088 EXPECT_EQ(static_cast<int64_t>(0x012345600123456Full), i63.getSExtValue()); 2089 2090 // Zero width insert is a noop. 2091 i31.insertBits(APInt::getZeroWidth(), 1); 2092 EXPECT_EQ(static_cast<int64_t>(0x00123456ull), i31.getSExtValue()); 2093 2094 // Insert single word src into one word of dst. 2095 APInt i120(120, UINT64_MAX, true); 2096 i120.insertBits(iSrc, 8); 2097 EXPECT_EQ(static_cast<int64_t>(0xFFFFFF80123456FFull), i120.getSExtValue()); 2098 2099 // Insert single word src into two words of dst. 2100 APInt i127(127, UINT64_MAX, true); 2101 i127.insertBits(iSrc, 48); 2102 EXPECT_EQ(i127.extractBits(64, 0).getZExtValue(), 0x3456FFFFFFFFFFFFull); 2103 EXPECT_EQ(i127.extractBits(63, 64).getZExtValue(), 0x7FFFFFFFFFFF8012ull); 2104 2105 // Insert on word boundaries. 2106 APInt i128(128, 0); 2107 i128.insertBits(APInt(64, UINT64_MAX, true), 0); 2108 i128.insertBits(APInt(64, UINT64_MAX, true), 64); 2109 EXPECT_EQ(-1, i128.getSExtValue()); 2110 2111 APInt i256(256, UINT64_MAX, true); 2112 i256.insertBits(APInt(65, 0), 0); 2113 i256.insertBits(APInt(69, 0), 64); 2114 i256.insertBits(APInt(128, 0), 128); 2115 EXPECT_EQ(0u, i256.getSExtValue()); 2116 2117 APInt i257(257, 0); 2118 i257.insertBits(APInt(96, UINT64_MAX, true), 64); 2119 EXPECT_EQ(i257.extractBits(64, 0).getZExtValue(), 0x0000000000000000ull); 2120 EXPECT_EQ(i257.extractBits(64, 64).getZExtValue(), 0xFFFFFFFFFFFFFFFFull); 2121 EXPECT_EQ(i257.extractBits(64, 128).getZExtValue(), 0x00000000FFFFFFFFull); 2122 EXPECT_EQ(i257.extractBits(65, 192).getZExtValue(), 0x0000000000000000ull); 2123 2124 // General insertion. 2125 APInt i260(260, UINT64_MAX, true); 2126 i260.insertBits(APInt(129, 1ull << 48), 15); 2127 EXPECT_EQ(i260.extractBits(64, 0).getZExtValue(), 0x8000000000007FFFull); 2128 EXPECT_EQ(i260.extractBits(64, 64).getZExtValue(), 0x0000000000000000ull); 2129 EXPECT_EQ(i260.extractBits(64, 128).getZExtValue(), 0xFFFFFFFFFFFF0000ull); 2130 EXPECT_EQ(i260.extractBits(64, 192).getZExtValue(), 0xFFFFFFFFFFFFFFFFull); 2131 EXPECT_EQ(i260.extractBits(4, 256).getZExtValue(), 0x000000000000000Full); 2132 } 2133 2134 TEST(APIntTest, insertBitsUInt64) { 2135 // Tests cloned from insertBits but adapted to the numBits <= 64 constraint 2136 uint64_t iSrc = 0x00123456; 2137 2138 // Direct copy. 2139 APInt i31(31, 0x76543210ull); 2140 i31.insertBits(iSrc, 0, 31); 2141 EXPECT_EQ(static_cast<int64_t>(0x00123456ull), i31.getSExtValue()); 2142 2143 // Single word src/dst insertion. 2144 APInt i63(63, 0x01234567FFFFFFFFull); 2145 i63.insertBits(iSrc, 4, 31); 2146 EXPECT_EQ(static_cast<int64_t>(0x012345600123456Full), i63.getSExtValue()); 2147 2148 // Insert single word src into one word of dst. 2149 APInt i120(120, UINT64_MAX, true); 2150 i120.insertBits(iSrc, 8, 31); 2151 EXPECT_EQ(static_cast<int64_t>(0xFFFFFF80123456FFull), i120.getSExtValue()); 2152 2153 // Insert single word src into two words of dst. 2154 APInt i127(127, UINT64_MAX, true); 2155 i127.insertBits(iSrc, 48, 31); 2156 EXPECT_EQ(i127.extractBits(64, 0).getZExtValue(), 0x3456FFFFFFFFFFFFull); 2157 EXPECT_EQ(i127.extractBits(63, 64).getZExtValue(), 0x7FFFFFFFFFFF8012ull); 2158 2159 // Insert on word boundaries. 2160 APInt i128(128, 0); 2161 i128.insertBits(UINT64_MAX, 0, 64); 2162 i128.insertBits(UINT64_MAX, 64, 64); 2163 EXPECT_EQ(-1, i128.getSExtValue()); 2164 2165 APInt i256(256, UINT64_MAX, true); 2166 i256.insertBits(0, 0, 64); 2167 i256.insertBits(0, 64, 1); 2168 i256.insertBits(0, 64, 64); 2169 i256.insertBits(0, 128, 5); 2170 i256.insertBits(0, 128, 64); 2171 i256.insertBits(0, 192, 64); 2172 EXPECT_EQ(0u, i256.getSExtValue()); 2173 2174 APInt i257(257, 0); 2175 i257.insertBits(APInt(96, UINT64_MAX, true), 64); 2176 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 0), 0x0000000000000000ull); 2177 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 64), 0xFFFFFFFFFFFFFFFFull); 2178 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 128), 0x00000000FFFFFFFFull); 2179 EXPECT_EQ(i257.extractBitsAsZExtValue(64, 192), 0x0000000000000000ull); 2180 EXPECT_EQ(i257.extractBitsAsZExtValue(1, 256), 0x0000000000000000ull); 2181 2182 // General insertion. 2183 APInt i260(260, UINT64_MAX, true); 2184 i260.insertBits(APInt(129, 1ull << 48), 15); 2185 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 0), 0x8000000000007FFFull); 2186 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 64), 0x0000000000000000ull); 2187 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 128), 0xFFFFFFFFFFFF0000ull); 2188 EXPECT_EQ(i260.extractBitsAsZExtValue(64, 192), 0xFFFFFFFFFFFFFFFFull); 2189 EXPECT_EQ(i260.extractBitsAsZExtValue(4, 256), 0x000000000000000Full); 2190 } 2191 2192 TEST(APIntTest, extractBits) { 2193 APInt i32(32, 0x1234567); 2194 EXPECT_EQ(0x3456, i32.extractBits(16, 4)); 2195 2196 APInt i64(64, 0x01234567FFFFFFFFull); 2197 EXPECT_EQ(0xFFFFFFFF, i64.extractBits(32, 0)); 2198 EXPECT_EQ(0xFFFFFFFF, i64.trunc(32)); 2199 EXPECT_EQ(0x01234567, i64.extractBits(32, 32)); 2200 EXPECT_EQ(0x01234567, i64.lshr(32).trunc(32)); 2201 2202 APInt i257(257, 0xFFFFFFFFFF0000FFull, true); 2203 EXPECT_EQ(0xFFu, i257.extractBits(16, 0)); 2204 EXPECT_EQ(0xFFu, i257.lshr(0).trunc(16)); 2205 EXPECT_EQ((0xFFu >> 1), i257.extractBits(16, 1)); 2206 EXPECT_EQ((0xFFu >> 1), i257.lshr(1).trunc(16)); 2207 EXPECT_EQ(-1, i257.extractBits(32, 64).getSExtValue()); 2208 EXPECT_EQ(-1, i257.lshr(64).trunc(32).getSExtValue()); 2209 EXPECT_EQ(-1, i257.extractBits(128, 128).getSExtValue()); 2210 EXPECT_EQ(-1, i257.lshr(128).trunc(128).getSExtValue()); 2211 EXPECT_EQ(-1, i257.extractBits(66, 191).getSExtValue()); 2212 EXPECT_EQ(-1, i257.lshr(191).trunc(66).getSExtValue()); 2213 EXPECT_EQ(static_cast<int64_t>(0xFFFFFFFFFF80007Full), 2214 i257.extractBits(128, 1).getSExtValue()); 2215 EXPECT_EQ(static_cast<int64_t>(0xFFFFFFFFFF80007Full), 2216 i257.lshr(1).trunc(128).getSExtValue()); 2217 EXPECT_EQ(static_cast<int64_t>(0xFFFFFFFFFF80007Full), 2218 i257.extractBits(129, 1).getSExtValue()); 2219 EXPECT_EQ(static_cast<int64_t>(0xFFFFFFFFFF80007Full), 2220 i257.lshr(1).trunc(129).getSExtValue()); 2221 2222 EXPECT_EQ(APInt(48, 0), 2223 APInt(144, "281474976710655", 10).extractBits(48, 48)); 2224 EXPECT_EQ(APInt(48, 0), 2225 APInt(144, "281474976710655", 10).lshr(48).trunc(48)); 2226 EXPECT_EQ(APInt(48, 0x0000ffffffffffffull), 2227 APInt(144, "281474976710655", 10).extractBits(48, 0)); 2228 EXPECT_EQ(APInt(48, 0x0000ffffffffffffull), 2229 APInt(144, "281474976710655", 10).lshr(0).trunc(48)); 2230 EXPECT_EQ(APInt(48, 0x00007fffffffffffull), 2231 APInt(144, "281474976710655", 10).extractBits(48, 1)); 2232 EXPECT_EQ(APInt(48, 0x00007fffffffffffull), 2233 APInt(144, "281474976710655", 10).lshr(1).trunc(48)); 2234 } 2235 2236 TEST(APIntTest, extractBitsAsZExtValue) { 2237 // Tests based on extractBits 2238 APInt i32(32, 0x1234567); 2239 EXPECT_EQ(0x3456u, i32.extractBitsAsZExtValue(16, 4)); 2240 2241 APInt i257(257, 0xFFFFFFFFFF0000FFull, true); 2242 EXPECT_EQ(0xFFu, i257.extractBitsAsZExtValue(16, 0)); 2243 EXPECT_EQ((0xFFu >> 1), i257.extractBitsAsZExtValue(16, 1)); 2244 EXPECT_EQ(0xFFFFFFFFull, i257.extractBitsAsZExtValue(32, 64)); 2245 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 128)); 2246 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 192)); 2247 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 191)); 2248 EXPECT_EQ(0x3u, i257.extractBitsAsZExtValue(2, 255)); 2249 EXPECT_EQ(0xFFFFFFFFFF80007Full, i257.extractBitsAsZExtValue(64, 1)); 2250 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 65)); 2251 EXPECT_EQ(0xFFFFFFFFFF80007Full, i257.extractBitsAsZExtValue(64, 1)); 2252 EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, i257.extractBitsAsZExtValue(64, 65)); 2253 EXPECT_EQ(0x1ull, i257.extractBitsAsZExtValue(1, 129)); 2254 2255 EXPECT_EQ(APInt(48, 0), 2256 APInt(144, "281474976710655", 10).extractBitsAsZExtValue(48, 48)); 2257 EXPECT_EQ(APInt(48, 0x0000ffffffffffffull), 2258 APInt(144, "281474976710655", 10).extractBitsAsZExtValue(48, 0)); 2259 EXPECT_EQ(APInt(48, 0x00007fffffffffffull), 2260 APInt(144, "281474976710655", 10).extractBitsAsZExtValue(48, 1)); 2261 } 2262 2263 TEST(APIntTest, getLowBitsSet) { 2264 APInt i128lo64 = APInt::getLowBitsSet(128, 64); 2265 EXPECT_EQ(0u, i128lo64.countl_one()); 2266 EXPECT_EQ(64u, i128lo64.countl_zero()); 2267 EXPECT_EQ(64u, i128lo64.getActiveBits()); 2268 EXPECT_EQ(0u, i128lo64.countr_zero()); 2269 EXPECT_EQ(64u, i128lo64.countr_one()); 2270 EXPECT_EQ(64u, i128lo64.popcount()); 2271 } 2272 2273 TEST(APIntTest, getBitsSet) { 2274 APInt i64hi1lo1 = APInt::getBitsSet(64, 1, 63); 2275 EXPECT_EQ(0u, i64hi1lo1.countl_one()); 2276 EXPECT_EQ(1u, i64hi1lo1.countl_zero()); 2277 EXPECT_EQ(63u, i64hi1lo1.getActiveBits()); 2278 EXPECT_EQ(1u, i64hi1lo1.countr_zero()); 2279 EXPECT_EQ(0u, i64hi1lo1.countr_one()); 2280 EXPECT_EQ(62u, i64hi1lo1.popcount()); 2281 2282 APInt i127hi1lo1 = APInt::getBitsSet(127, 1, 126); 2283 EXPECT_EQ(0u, i127hi1lo1.countl_one()); 2284 EXPECT_EQ(1u, i127hi1lo1.countl_zero()); 2285 EXPECT_EQ(126u, i127hi1lo1.getActiveBits()); 2286 EXPECT_EQ(1u, i127hi1lo1.countr_zero()); 2287 EXPECT_EQ(0u, i127hi1lo1.countr_one()); 2288 EXPECT_EQ(125u, i127hi1lo1.popcount()); 2289 } 2290 2291 TEST(APIntTest, getBitsSetWithWrap) { 2292 APInt i64hi1lo1 = APInt::getBitsSetWithWrap(64, 1, 63); 2293 EXPECT_EQ(0u, i64hi1lo1.countl_one()); 2294 EXPECT_EQ(1u, i64hi1lo1.countl_zero()); 2295 EXPECT_EQ(63u, i64hi1lo1.getActiveBits()); 2296 EXPECT_EQ(1u, i64hi1lo1.countr_zero()); 2297 EXPECT_EQ(0u, i64hi1lo1.countr_one()); 2298 EXPECT_EQ(62u, i64hi1lo1.popcount()); 2299 2300 APInt i127hi1lo1 = APInt::getBitsSetWithWrap(127, 1, 126); 2301 EXPECT_EQ(0u, i127hi1lo1.countl_one()); 2302 EXPECT_EQ(1u, i127hi1lo1.countl_zero()); 2303 EXPECT_EQ(126u, i127hi1lo1.getActiveBits()); 2304 EXPECT_EQ(1u, i127hi1lo1.countr_zero()); 2305 EXPECT_EQ(0u, i127hi1lo1.countr_one()); 2306 EXPECT_EQ(125u, i127hi1lo1.popcount()); 2307 2308 APInt i64hi1lo1wrap = APInt::getBitsSetWithWrap(64, 63, 1); 2309 EXPECT_EQ(1u, i64hi1lo1wrap.countl_one()); 2310 EXPECT_EQ(0u, i64hi1lo1wrap.countl_zero()); 2311 EXPECT_EQ(64u, i64hi1lo1wrap.getActiveBits()); 2312 EXPECT_EQ(0u, i64hi1lo1wrap.countr_zero()); 2313 EXPECT_EQ(1u, i64hi1lo1wrap.countr_one()); 2314 EXPECT_EQ(2u, i64hi1lo1wrap.popcount()); 2315 2316 APInt i127hi1lo1wrap = APInt::getBitsSetWithWrap(127, 126, 1); 2317 EXPECT_EQ(1u, i127hi1lo1wrap.countl_one()); 2318 EXPECT_EQ(0u, i127hi1lo1wrap.countl_zero()); 2319 EXPECT_EQ(127u, i127hi1lo1wrap.getActiveBits()); 2320 EXPECT_EQ(0u, i127hi1lo1wrap.countr_zero()); 2321 EXPECT_EQ(1u, i127hi1lo1wrap.countr_one()); 2322 EXPECT_EQ(2u, i127hi1lo1wrap.popcount()); 2323 2324 APInt i32hiequallowrap = APInt::getBitsSetWithWrap(32, 10, 10); 2325 EXPECT_EQ(32u, i32hiequallowrap.countl_one()); 2326 EXPECT_EQ(0u, i32hiequallowrap.countl_zero()); 2327 EXPECT_EQ(32u, i32hiequallowrap.getActiveBits()); 2328 EXPECT_EQ(0u, i32hiequallowrap.countr_zero()); 2329 EXPECT_EQ(32u, i32hiequallowrap.countr_one()); 2330 EXPECT_EQ(32u, i32hiequallowrap.popcount()); 2331 } 2332 2333 TEST(APIntTest, getHighBitsSet) { 2334 APInt i64hi32 = APInt::getHighBitsSet(64, 32); 2335 EXPECT_EQ(32u, i64hi32.countl_one()); 2336 EXPECT_EQ(0u, i64hi32.countl_zero()); 2337 EXPECT_EQ(64u, i64hi32.getActiveBits()); 2338 EXPECT_EQ(32u, i64hi32.countr_zero()); 2339 EXPECT_EQ(0u, i64hi32.countr_one()); 2340 EXPECT_EQ(32u, i64hi32.popcount()); 2341 } 2342 2343 TEST(APIntTest, getBitsSetFrom) { 2344 APInt i64hi31 = APInt::getBitsSetFrom(64, 33); 2345 EXPECT_EQ(31u, i64hi31.countl_one()); 2346 EXPECT_EQ(0u, i64hi31.countl_zero()); 2347 EXPECT_EQ(64u, i64hi31.getActiveBits()); 2348 EXPECT_EQ(33u, i64hi31.countr_zero()); 2349 EXPECT_EQ(0u, i64hi31.countr_one()); 2350 EXPECT_EQ(31u, i64hi31.popcount()); 2351 } 2352 2353 TEST(APIntTest, setLowBits) { 2354 APInt i64lo32(64, 0); 2355 i64lo32.setLowBits(32); 2356 EXPECT_EQ(0u, i64lo32.countl_one()); 2357 EXPECT_EQ(32u, i64lo32.countl_zero()); 2358 EXPECT_EQ(32u, i64lo32.getActiveBits()); 2359 EXPECT_EQ(0u, i64lo32.countr_zero()); 2360 EXPECT_EQ(32u, i64lo32.countr_one()); 2361 EXPECT_EQ(32u, i64lo32.popcount()); 2362 2363 APInt i128lo64(128, 0); 2364 i128lo64.setLowBits(64); 2365 EXPECT_EQ(0u, i128lo64.countl_one()); 2366 EXPECT_EQ(64u, i128lo64.countl_zero()); 2367 EXPECT_EQ(64u, i128lo64.getActiveBits()); 2368 EXPECT_EQ(0u, i128lo64.countr_zero()); 2369 EXPECT_EQ(64u, i128lo64.countr_one()); 2370 EXPECT_EQ(64u, i128lo64.popcount()); 2371 2372 APInt i128lo24(128, 0); 2373 i128lo24.setLowBits(24); 2374 EXPECT_EQ(0u, i128lo24.countl_one()); 2375 EXPECT_EQ(104u, i128lo24.countl_zero()); 2376 EXPECT_EQ(24u, i128lo24.getActiveBits()); 2377 EXPECT_EQ(0u, i128lo24.countr_zero()); 2378 EXPECT_EQ(24u, i128lo24.countr_one()); 2379 EXPECT_EQ(24u, i128lo24.popcount()); 2380 2381 APInt i128lo104(128, 0); 2382 i128lo104.setLowBits(104); 2383 EXPECT_EQ(0u, i128lo104.countl_one()); 2384 EXPECT_EQ(24u, i128lo104.countl_zero()); 2385 EXPECT_EQ(104u, i128lo104.getActiveBits()); 2386 EXPECT_EQ(0u, i128lo104.countr_zero()); 2387 EXPECT_EQ(104u, i128lo104.countr_one()); 2388 EXPECT_EQ(104u, i128lo104.popcount()); 2389 2390 APInt i128lo0(128, 0); 2391 i128lo0.setLowBits(0); 2392 EXPECT_EQ(0u, i128lo0.countl_one()); 2393 EXPECT_EQ(128u, i128lo0.countl_zero()); 2394 EXPECT_EQ(0u, i128lo0.getActiveBits()); 2395 EXPECT_EQ(128u, i128lo0.countr_zero()); 2396 EXPECT_EQ(0u, i128lo0.countr_one()); 2397 EXPECT_EQ(0u, i128lo0.popcount()); 2398 2399 APInt i80lo79(80, 0); 2400 i80lo79.setLowBits(79); 2401 EXPECT_EQ(0u, i80lo79.countl_one()); 2402 EXPECT_EQ(1u, i80lo79.countl_zero()); 2403 EXPECT_EQ(79u, i80lo79.getActiveBits()); 2404 EXPECT_EQ(0u, i80lo79.countr_zero()); 2405 EXPECT_EQ(79u, i80lo79.countr_one()); 2406 EXPECT_EQ(79u, i80lo79.popcount()); 2407 } 2408 2409 TEST(APIntTest, setHighBits) { 2410 APInt i64hi32(64, 0); 2411 i64hi32.setHighBits(32); 2412 EXPECT_EQ(32u, i64hi32.countl_one()); 2413 EXPECT_EQ(0u, i64hi32.countl_zero()); 2414 EXPECT_EQ(64u, i64hi32.getActiveBits()); 2415 EXPECT_EQ(32u, i64hi32.countr_zero()); 2416 EXPECT_EQ(0u, i64hi32.countr_one()); 2417 EXPECT_EQ(32u, i64hi32.popcount()); 2418 2419 APInt i128hi64(128, 0); 2420 i128hi64.setHighBits(64); 2421 EXPECT_EQ(64u, i128hi64.countl_one()); 2422 EXPECT_EQ(0u, i128hi64.countl_zero()); 2423 EXPECT_EQ(128u, i128hi64.getActiveBits()); 2424 EXPECT_EQ(64u, i128hi64.countr_zero()); 2425 EXPECT_EQ(0u, i128hi64.countr_one()); 2426 EXPECT_EQ(64u, i128hi64.popcount()); 2427 2428 APInt i128hi24(128, 0); 2429 i128hi24.setHighBits(24); 2430 EXPECT_EQ(24u, i128hi24.countl_one()); 2431 EXPECT_EQ(0u, i128hi24.countl_zero()); 2432 EXPECT_EQ(128u, i128hi24.getActiveBits()); 2433 EXPECT_EQ(104u, i128hi24.countr_zero()); 2434 EXPECT_EQ(0u, i128hi24.countr_one()); 2435 EXPECT_EQ(24u, i128hi24.popcount()); 2436 2437 APInt i128hi104(128, 0); 2438 i128hi104.setHighBits(104); 2439 EXPECT_EQ(104u, i128hi104.countl_one()); 2440 EXPECT_EQ(0u, i128hi104.countl_zero()); 2441 EXPECT_EQ(128u, i128hi104.getActiveBits()); 2442 EXPECT_EQ(24u, i128hi104.countr_zero()); 2443 EXPECT_EQ(0u, i128hi104.countr_one()); 2444 EXPECT_EQ(104u, i128hi104.popcount()); 2445 2446 APInt i128hi0(128, 0); 2447 i128hi0.setHighBits(0); 2448 EXPECT_EQ(0u, i128hi0.countl_one()); 2449 EXPECT_EQ(128u, i128hi0.countl_zero()); 2450 EXPECT_EQ(0u, i128hi0.getActiveBits()); 2451 EXPECT_EQ(128u, i128hi0.countr_zero()); 2452 EXPECT_EQ(0u, i128hi0.countr_one()); 2453 EXPECT_EQ(0u, i128hi0.popcount()); 2454 2455 APInt i80hi1(80, 0); 2456 i80hi1.setHighBits(1); 2457 EXPECT_EQ(1u, i80hi1.countl_one()); 2458 EXPECT_EQ(0u, i80hi1.countl_zero()); 2459 EXPECT_EQ(80u, i80hi1.getActiveBits()); 2460 EXPECT_EQ(79u, i80hi1.countr_zero()); 2461 EXPECT_EQ(0u, i80hi1.countr_one()); 2462 EXPECT_EQ(1u, i80hi1.popcount()); 2463 2464 APInt i32hi16(32, 0); 2465 i32hi16.setHighBits(16); 2466 EXPECT_EQ(16u, i32hi16.countl_one()); 2467 EXPECT_EQ(0u, i32hi16.countl_zero()); 2468 EXPECT_EQ(32u, i32hi16.getActiveBits()); 2469 EXPECT_EQ(16u, i32hi16.countr_zero()); 2470 EXPECT_EQ(0u, i32hi16.countr_one()); 2471 EXPECT_EQ(16u, i32hi16.popcount()); 2472 } 2473 2474 TEST(APIntTest, setBitsFrom) { 2475 APInt i64from63(64, 0); 2476 i64from63.setBitsFrom(63); 2477 EXPECT_EQ(1u, i64from63.countl_one()); 2478 EXPECT_EQ(0u, i64from63.countl_zero()); 2479 EXPECT_EQ(64u, i64from63.getActiveBits()); 2480 EXPECT_EQ(63u, i64from63.countr_zero()); 2481 EXPECT_EQ(0u, i64from63.countr_one()); 2482 EXPECT_EQ(1u, i64from63.popcount()); 2483 } 2484 2485 TEST(APIntTest, setAllBits) { 2486 APInt i32(32, 0); 2487 i32.setAllBits(); 2488 EXPECT_EQ(32u, i32.countl_one()); 2489 EXPECT_EQ(0u, i32.countl_zero()); 2490 EXPECT_EQ(32u, i32.getActiveBits()); 2491 EXPECT_EQ(0u, i32.countr_zero()); 2492 EXPECT_EQ(32u, i32.countr_one()); 2493 EXPECT_EQ(32u, i32.popcount()); 2494 2495 APInt i64(64, 0); 2496 i64.setAllBits(); 2497 EXPECT_EQ(64u, i64.countl_one()); 2498 EXPECT_EQ(0u, i64.countl_zero()); 2499 EXPECT_EQ(64u, i64.getActiveBits()); 2500 EXPECT_EQ(0u, i64.countr_zero()); 2501 EXPECT_EQ(64u, i64.countr_one()); 2502 EXPECT_EQ(64u, i64.popcount()); 2503 2504 APInt i96(96, 0); 2505 i96.setAllBits(); 2506 EXPECT_EQ(96u, i96.countl_one()); 2507 EXPECT_EQ(0u, i96.countl_zero()); 2508 EXPECT_EQ(96u, i96.getActiveBits()); 2509 EXPECT_EQ(0u, i96.countr_zero()); 2510 EXPECT_EQ(96u, i96.countr_one()); 2511 EXPECT_EQ(96u, i96.popcount()); 2512 2513 APInt i128(128, 0); 2514 i128.setAllBits(); 2515 EXPECT_EQ(128u, i128.countl_one()); 2516 EXPECT_EQ(0u, i128.countl_zero()); 2517 EXPECT_EQ(128u, i128.getActiveBits()); 2518 EXPECT_EQ(0u, i128.countr_zero()); 2519 EXPECT_EQ(128u, i128.countr_one()); 2520 EXPECT_EQ(128u, i128.popcount()); 2521 } 2522 2523 TEST(APIntTest, getLoBits) { 2524 APInt i32(32, 0xfa); 2525 i32.setHighBits(1); 2526 EXPECT_EQ(0xa, i32.getLoBits(4)); 2527 APInt i128(128, 0xfa); 2528 i128.setHighBits(1); 2529 EXPECT_EQ(0xa, i128.getLoBits(4)); 2530 } 2531 2532 TEST(APIntTest, getHiBits) { 2533 APInt i32(32, 0xfa); 2534 i32.setHighBits(2); 2535 EXPECT_EQ(0xc, i32.getHiBits(4)); 2536 APInt i128(128, 0xfa); 2537 i128.setHighBits(2); 2538 EXPECT_EQ(0xc, i128.getHiBits(4)); 2539 } 2540 2541 TEST(APIntTest, clearLowBits) { 2542 APInt i64hi32 = APInt::getAllOnes(64); 2543 i64hi32.clearLowBits(32); 2544 EXPECT_EQ(32u, i64hi32.countl_one()); 2545 EXPECT_EQ(0u, i64hi32.countl_zero()); 2546 EXPECT_EQ(64u, i64hi32.getActiveBits()); 2547 EXPECT_EQ(32u, i64hi32.countr_zero()); 2548 EXPECT_EQ(0u, i64hi32.countr_one()); 2549 EXPECT_EQ(32u, i64hi32.popcount()); 2550 2551 APInt i128hi64 = APInt::getAllOnes(128); 2552 i128hi64.clearLowBits(64); 2553 EXPECT_EQ(64u, i128hi64.countl_one()); 2554 EXPECT_EQ(0u, i128hi64.countl_zero()); 2555 EXPECT_EQ(128u, i128hi64.getActiveBits()); 2556 EXPECT_EQ(64u, i128hi64.countr_zero()); 2557 EXPECT_EQ(0u, i128hi64.countr_one()); 2558 EXPECT_EQ(64u, i128hi64.popcount()); 2559 2560 APInt i128hi24 = APInt::getAllOnes(128); 2561 i128hi24.clearLowBits(104); 2562 EXPECT_EQ(24u, i128hi24.countl_one()); 2563 EXPECT_EQ(0u, i128hi24.countl_zero()); 2564 EXPECT_EQ(128u, i128hi24.getActiveBits()); 2565 EXPECT_EQ(104u, i128hi24.countr_zero()); 2566 EXPECT_EQ(0u, i128hi24.countr_one()); 2567 EXPECT_EQ(24u, i128hi24.popcount()); 2568 2569 APInt i128hi104 = APInt::getAllOnes(128); 2570 i128hi104.clearLowBits(24); 2571 EXPECT_EQ(104u, i128hi104.countl_one()); 2572 EXPECT_EQ(0u, i128hi104.countl_zero()); 2573 EXPECT_EQ(128u, i128hi104.getActiveBits()); 2574 EXPECT_EQ(24u, i128hi104.countr_zero()); 2575 EXPECT_EQ(0u, i128hi104.countr_one()); 2576 EXPECT_EQ(104u, i128hi104.popcount()); 2577 2578 APInt i128hi0 = APInt::getAllOnes(128); 2579 i128hi0.clearLowBits(128); 2580 EXPECT_EQ(0u, i128hi0.countl_one()); 2581 EXPECT_EQ(128u, i128hi0.countl_zero()); 2582 EXPECT_EQ(0u, i128hi0.getActiveBits()); 2583 EXPECT_EQ(128u, i128hi0.countr_zero()); 2584 EXPECT_EQ(0u, i128hi0.countr_one()); 2585 EXPECT_EQ(0u, i128hi0.popcount()); 2586 2587 APInt i80hi1 = APInt::getAllOnes(80); 2588 i80hi1.clearLowBits(79); 2589 EXPECT_EQ(1u, i80hi1.countl_one()); 2590 EXPECT_EQ(0u, i80hi1.countl_zero()); 2591 EXPECT_EQ(80u, i80hi1.getActiveBits()); 2592 EXPECT_EQ(79u, i80hi1.countr_zero()); 2593 EXPECT_EQ(0u, i80hi1.countr_one()); 2594 EXPECT_EQ(1u, i80hi1.popcount()); 2595 2596 APInt i32hi16 = APInt::getAllOnes(32); 2597 i32hi16.clearLowBits(16); 2598 EXPECT_EQ(16u, i32hi16.countl_one()); 2599 EXPECT_EQ(0u, i32hi16.countl_zero()); 2600 EXPECT_EQ(32u, i32hi16.getActiveBits()); 2601 EXPECT_EQ(16u, i32hi16.countr_zero()); 2602 EXPECT_EQ(0u, i32hi16.countr_one()); 2603 EXPECT_EQ(16u, i32hi16.popcount()); 2604 } 2605 2606 TEST(APIntTest, clearHighBits) { 2607 APInt i64hi32 = APInt::getAllOnes(64); 2608 i64hi32.clearHighBits(32); 2609 EXPECT_EQ(32u, i64hi32.countr_one()); 2610 EXPECT_EQ(0u, i64hi32.countr_zero()); 2611 EXPECT_EQ(32u, i64hi32.getActiveBits()); 2612 EXPECT_EQ(32u, i64hi32.countl_zero()); 2613 EXPECT_EQ(0u, i64hi32.countl_one()); 2614 EXPECT_EQ(32u, i64hi32.popcount()); 2615 2616 APInt i128hi64 = APInt::getAllOnes(128); 2617 i128hi64.clearHighBits(64); 2618 EXPECT_EQ(64u, i128hi64.countr_one()); 2619 EXPECT_EQ(0u, i128hi64.countr_zero()); 2620 EXPECT_EQ(64u, i128hi64.getActiveBits()); 2621 EXPECT_EQ(64u, i128hi64.countl_zero()); 2622 EXPECT_EQ(0u, i128hi64.countl_one()); 2623 EXPECT_EQ(64u, i128hi64.popcount()); 2624 2625 APInt i128hi24 = APInt::getAllOnes(128); 2626 i128hi24.clearHighBits(104); 2627 EXPECT_EQ(24u, i128hi24.countr_one()); 2628 EXPECT_EQ(0u, i128hi24.countr_zero()); 2629 EXPECT_EQ(24u, i128hi24.getActiveBits()); 2630 EXPECT_EQ(104u, i128hi24.countl_zero()); 2631 EXPECT_EQ(0u, i128hi24.countl_one()); 2632 EXPECT_EQ(24u, i128hi24.popcount()); 2633 2634 APInt i128hi104 = APInt::getAllOnes(128); 2635 i128hi104.clearHighBits(24); 2636 EXPECT_EQ(104u, i128hi104.countr_one()); 2637 EXPECT_EQ(0u, i128hi104.countr_zero()); 2638 EXPECT_EQ(104u, i128hi104.getActiveBits()); 2639 EXPECT_EQ(24u, i128hi104.countl_zero()); 2640 EXPECT_EQ(0u, i128hi104.countl_one()); 2641 EXPECT_EQ(104u, i128hi104.popcount()); 2642 2643 APInt i128hi0 = APInt::getAllOnes(128); 2644 i128hi0.clearHighBits(128); 2645 EXPECT_EQ(0u, i128hi0.countr_one()); 2646 EXPECT_EQ(128u, i128hi0.countr_zero()); 2647 EXPECT_EQ(0u, i128hi0.getActiveBits()); 2648 EXPECT_EQ(128u, i128hi0.countl_zero()); 2649 EXPECT_EQ(0u, i128hi0.countl_one()); 2650 EXPECT_EQ(0u, i128hi0.popcount()); 2651 2652 APInt i80hi1 = APInt::getAllOnes(80); 2653 i80hi1.clearHighBits(79); 2654 EXPECT_EQ(1u, i80hi1.countr_one()); 2655 EXPECT_EQ(0u, i80hi1.countr_zero()); 2656 EXPECT_EQ(1u, i80hi1.getActiveBits()); 2657 EXPECT_EQ(79u, i80hi1.countl_zero()); 2658 EXPECT_EQ(0u, i80hi1.countl_one()); 2659 EXPECT_EQ(1u, i80hi1.popcount()); 2660 2661 APInt i32hi16 = APInt::getAllOnes(32); 2662 i32hi16.clearHighBits(16); 2663 EXPECT_EQ(16u, i32hi16.countr_one()); 2664 EXPECT_EQ(0u, i32hi16.countr_zero()); 2665 EXPECT_EQ(16u, i32hi16.getActiveBits()); 2666 EXPECT_EQ(16u, i32hi16.countl_zero()); 2667 EXPECT_EQ(0u, i32hi16.countl_one()); 2668 EXPECT_EQ(16u, i32hi16.popcount()); 2669 } 2670 2671 TEST(APIntTest, abds) { 2672 using APIntOps::abds; 2673 2674 APInt MaxU1(1, 1, false); 2675 APInt MinU1(1, 0, false); 2676 EXPECT_EQ(1u, abds(MaxU1, MinU1).getZExtValue()); 2677 EXPECT_EQ(1u, abds(MinU1, MaxU1).getZExtValue()); 2678 2679 APInt MaxU4(4, 15, false); 2680 APInt MinU4(4, 0, false); 2681 EXPECT_EQ(1, abds(MaxU4, MinU4).getSExtValue()); 2682 EXPECT_EQ(1, abds(MinU4, MaxU4).getSExtValue()); 2683 2684 APInt MaxS8(8, 127, true); 2685 APInt MinS8(8, -128, true); 2686 EXPECT_EQ(-1, abds(MaxS8, MinS8).getSExtValue()); 2687 EXPECT_EQ(-1, abds(MinS8, MaxS8).getSExtValue()); 2688 2689 APInt MaxU16(16, 65535, false); 2690 APInt MinU16(16, 0, false); 2691 EXPECT_EQ(1, abds(MaxU16, MinU16).getSExtValue()); 2692 EXPECT_EQ(1, abds(MinU16, MaxU16).getSExtValue()); 2693 2694 APInt MaxS16(16, 32767, true); 2695 APInt MinS16(16, -32768, true); 2696 APInt ZeroS16(16, 0, true); 2697 EXPECT_EQ(-1, abds(MaxS16, MinS16).getSExtValue()); 2698 EXPECT_EQ(-1, abds(MinS16, MaxS16).getSExtValue()); 2699 EXPECT_EQ(32768u, abds(ZeroS16, MinS16)); 2700 EXPECT_EQ(32768u, abds(MinS16, ZeroS16)); 2701 EXPECT_EQ(32767u, abds(ZeroS16, MaxS16)); 2702 EXPECT_EQ(32767u, abds(MaxS16, ZeroS16)); 2703 } 2704 2705 TEST(APIntTest, abdu) { 2706 using APIntOps::abdu; 2707 2708 APInt MaxU1(1, 1, false); 2709 APInt MinU1(1, 0, false); 2710 EXPECT_EQ(1u, abdu(MaxU1, MinU1).getZExtValue()); 2711 EXPECT_EQ(1u, abdu(MinU1, MaxU1).getZExtValue()); 2712 2713 APInt MaxU4(4, 15, false); 2714 APInt MinU4(4, 0, false); 2715 EXPECT_EQ(15u, abdu(MaxU4, MinU4).getZExtValue()); 2716 EXPECT_EQ(15u, abdu(MinU4, MaxU4).getZExtValue()); 2717 2718 APInt MaxS8(8, 127, true); 2719 APInt MinS8(8, -128, true); 2720 EXPECT_EQ(1u, abdu(MaxS8, MinS8).getZExtValue()); 2721 EXPECT_EQ(1u, abdu(MinS8, MaxS8).getZExtValue()); 2722 2723 APInt MaxU16(16, 65535, false); 2724 APInt MinU16(16, 0, false); 2725 EXPECT_EQ(65535u, abdu(MaxU16, MinU16).getZExtValue()); 2726 EXPECT_EQ(65535u, abdu(MinU16, MaxU16).getZExtValue()); 2727 2728 APInt MaxS16(16, 32767, true); 2729 APInt MinS16(16, -32768, true); 2730 APInt ZeroS16(16, 0, true); 2731 EXPECT_EQ(1u, abdu(MaxS16, MinS16).getZExtValue()); 2732 EXPECT_EQ(1u, abdu(MinS16, MaxS16).getZExtValue()); 2733 EXPECT_EQ(32768u, abdu(ZeroS16, MinS16)); 2734 EXPECT_EQ(32768u, abdu(MinS16, ZeroS16)); 2735 EXPECT_EQ(32767u, abdu(ZeroS16, MaxS16)); 2736 EXPECT_EQ(32767u, abdu(MaxS16, ZeroS16)); 2737 } 2738 2739 TEST(APIntTest, GCD) { 2740 using APIntOps::GreatestCommonDivisor; 2741 2742 for (unsigned Bits : {1, 2, 32, 63, 64, 65}) { 2743 // Test some corner cases near zero. 2744 APInt Zero(Bits, 0), One(Bits, 1); 2745 EXPECT_EQ(GreatestCommonDivisor(Zero, Zero), Zero); 2746 EXPECT_EQ(GreatestCommonDivisor(Zero, One), One); 2747 EXPECT_EQ(GreatestCommonDivisor(One, Zero), One); 2748 EXPECT_EQ(GreatestCommonDivisor(One, One), One); 2749 2750 if (Bits > 1) { 2751 APInt Two(Bits, 2); 2752 EXPECT_EQ(GreatestCommonDivisor(Zero, Two), Two); 2753 EXPECT_EQ(GreatestCommonDivisor(One, Two), One); 2754 EXPECT_EQ(GreatestCommonDivisor(Two, Two), Two); 2755 2756 // Test some corner cases near the highest representable value. 2757 APInt Max(Bits, 0); 2758 Max.setAllBits(); 2759 EXPECT_EQ(GreatestCommonDivisor(Zero, Max), Max); 2760 EXPECT_EQ(GreatestCommonDivisor(One, Max), One); 2761 EXPECT_EQ(GreatestCommonDivisor(Two, Max), One); 2762 EXPECT_EQ(GreatestCommonDivisor(Max, Max), Max); 2763 2764 APInt MaxOver2 = Max.udiv(Two); 2765 EXPECT_EQ(GreatestCommonDivisor(MaxOver2, Max), One); 2766 // Max - 1 == Max / 2 * 2, because Max is odd. 2767 EXPECT_EQ(GreatestCommonDivisor(MaxOver2, Max - 1), MaxOver2); 2768 } 2769 } 2770 2771 // Compute the 20th Mersenne prime. 2772 const unsigned BitWidth = 4450; 2773 APInt HugePrime = APInt::getLowBitsSet(BitWidth, 4423); 2774 2775 // 9931 and 123456 are coprime. 2776 APInt A = HugePrime * APInt(BitWidth, 9931); 2777 APInt B = HugePrime * APInt(BitWidth, 123456); 2778 APInt C = GreatestCommonDivisor(A, B); 2779 EXPECT_EQ(C, HugePrime); 2780 } 2781 2782 TEST(APIntTest, LogicalRightShift) { 2783 APInt i256(APInt::getHighBitsSet(256, 2)); 2784 2785 i256.lshrInPlace(1); 2786 EXPECT_EQ(1U, i256.countl_zero()); 2787 EXPECT_EQ(253U, i256.countr_zero()); 2788 EXPECT_EQ(2U, i256.popcount()); 2789 2790 i256.lshrInPlace(62); 2791 EXPECT_EQ(63U, i256.countl_zero()); 2792 EXPECT_EQ(191U, i256.countr_zero()); 2793 EXPECT_EQ(2U, i256.popcount()); 2794 2795 i256.lshrInPlace(65); 2796 EXPECT_EQ(128U, i256.countl_zero()); 2797 EXPECT_EQ(126U, i256.countr_zero()); 2798 EXPECT_EQ(2U, i256.popcount()); 2799 2800 i256.lshrInPlace(64); 2801 EXPECT_EQ(192U, i256.countl_zero()); 2802 EXPECT_EQ(62U, i256.countr_zero()); 2803 EXPECT_EQ(2U, i256.popcount()); 2804 2805 i256.lshrInPlace(63); 2806 EXPECT_EQ(255U, i256.countl_zero()); 2807 EXPECT_EQ(0U, i256.countr_zero()); 2808 EXPECT_EQ(1U, i256.popcount()); 2809 2810 // Ensure we handle large shifts of multi-word. 2811 const APInt neg_one(128, static_cast<uint64_t>(-1), true); 2812 EXPECT_EQ(0, neg_one.lshr(128)); 2813 } 2814 2815 TEST(APIntTest, ArithmeticRightShift) { 2816 APInt i72(APInt::getHighBitsSet(72, 1)); 2817 i72.ashrInPlace(46); 2818 EXPECT_EQ(47U, i72.countl_one()); 2819 EXPECT_EQ(25U, i72.countr_zero()); 2820 EXPECT_EQ(47U, i72.popcount()); 2821 2822 i72 = APInt::getHighBitsSet(72, 1); 2823 i72.ashrInPlace(64); 2824 EXPECT_EQ(65U, i72.countl_one()); 2825 EXPECT_EQ(7U, i72.countr_zero()); 2826 EXPECT_EQ(65U, i72.popcount()); 2827 2828 APInt i128(APInt::getHighBitsSet(128, 1)); 2829 i128.ashrInPlace(64); 2830 EXPECT_EQ(65U, i128.countl_one()); 2831 EXPECT_EQ(63U, i128.countr_zero()); 2832 EXPECT_EQ(65U, i128.popcount()); 2833 2834 // Ensure we handle large shifts of multi-word. 2835 const APInt signmin32(APInt::getSignedMinValue(32)); 2836 EXPECT_TRUE(signmin32.ashr(32).isAllOnes()); 2837 2838 // Ensure we handle large shifts of multi-word. 2839 const APInt umax32(APInt::getSignedMaxValue(32)); 2840 EXPECT_EQ(0, umax32.ashr(32)); 2841 2842 // Ensure we handle large shifts of multi-word. 2843 const APInt signmin128(APInt::getSignedMinValue(128)); 2844 EXPECT_TRUE(signmin128.ashr(128).isAllOnes()); 2845 2846 // Ensure we handle large shifts of multi-word. 2847 const APInt umax128(APInt::getSignedMaxValue(128)); 2848 EXPECT_EQ(0, umax128.ashr(128)); 2849 } 2850 2851 TEST(APIntTest, LeftShift) { 2852 APInt i256(APInt::getLowBitsSet(256, 2)); 2853 2854 i256 <<= 1; 2855 EXPECT_EQ(253U, i256.countl_zero()); 2856 EXPECT_EQ(1U, i256.countr_zero()); 2857 EXPECT_EQ(2U, i256.popcount()); 2858 2859 i256 <<= 62; 2860 EXPECT_EQ(191U, i256.countl_zero()); 2861 EXPECT_EQ(63U, i256.countr_zero()); 2862 EXPECT_EQ(2U, i256.popcount()); 2863 2864 i256 <<= 65; 2865 EXPECT_EQ(126U, i256.countl_zero()); 2866 EXPECT_EQ(128U, i256.countr_zero()); 2867 EXPECT_EQ(2U, i256.popcount()); 2868 2869 i256 <<= 64; 2870 EXPECT_EQ(62U, i256.countl_zero()); 2871 EXPECT_EQ(192U, i256.countr_zero()); 2872 EXPECT_EQ(2U, i256.popcount()); 2873 2874 i256 <<= 63; 2875 EXPECT_EQ(0U, i256.countl_zero()); 2876 EXPECT_EQ(255U, i256.countr_zero()); 2877 EXPECT_EQ(1U, i256.popcount()); 2878 2879 // Ensure we handle large shifts of multi-word. 2880 const APInt neg_one(128, static_cast<uint64_t>(-1), true); 2881 EXPECT_EQ(0, neg_one.shl(128)); 2882 } 2883 2884 TEST(APIntTest, isSubsetOf) { 2885 APInt i32_1(32, 1); 2886 APInt i32_2(32, 2); 2887 APInt i32_3(32, 3); 2888 EXPECT_FALSE(i32_3.isSubsetOf(i32_1)); 2889 EXPECT_TRUE(i32_1.isSubsetOf(i32_3)); 2890 EXPECT_FALSE(i32_2.isSubsetOf(i32_1)); 2891 EXPECT_FALSE(i32_1.isSubsetOf(i32_2)); 2892 EXPECT_TRUE(i32_3.isSubsetOf(i32_3)); 2893 2894 APInt i128_1(128, 1); 2895 APInt i128_2(128, 2); 2896 APInt i128_3(128, 3); 2897 EXPECT_FALSE(i128_3.isSubsetOf(i128_1)); 2898 EXPECT_TRUE(i128_1.isSubsetOf(i128_3)); 2899 EXPECT_FALSE(i128_2.isSubsetOf(i128_1)); 2900 EXPECT_FALSE(i128_1.isSubsetOf(i128_2)); 2901 EXPECT_TRUE(i128_3.isSubsetOf(i128_3)); 2902 2903 i128_1 <<= 64; 2904 i128_2 <<= 64; 2905 i128_3 <<= 64; 2906 EXPECT_FALSE(i128_3.isSubsetOf(i128_1)); 2907 EXPECT_TRUE(i128_1.isSubsetOf(i128_3)); 2908 EXPECT_FALSE(i128_2.isSubsetOf(i128_1)); 2909 EXPECT_FALSE(i128_1.isSubsetOf(i128_2)); 2910 EXPECT_TRUE(i128_3.isSubsetOf(i128_3)); 2911 } 2912 2913 TEST(APIntTest, sext) { 2914 EXPECT_EQ(0, APInt(1, 0).sext(64)); 2915 EXPECT_EQ(~uint64_t(0), APInt(1, 1).sext(64)); 2916 2917 APInt i32_max(APInt::getSignedMaxValue(32).sext(63)); 2918 EXPECT_EQ(i32_max, i32_max.sext(63)); 2919 EXPECT_EQ(32U, i32_max.countl_zero()); 2920 EXPECT_EQ(0U, i32_max.countr_zero()); 2921 EXPECT_EQ(31U, i32_max.popcount()); 2922 2923 APInt i32_min(APInt::getSignedMinValue(32).sext(63)); 2924 EXPECT_EQ(i32_min, i32_min.sext(63)); 2925 EXPECT_EQ(32U, i32_min.countl_one()); 2926 EXPECT_EQ(31U, i32_min.countr_zero()); 2927 EXPECT_EQ(32U, i32_min.popcount()); 2928 2929 APInt i32_neg1(APInt(32, ~uint32_t(0)).sext(63)); 2930 EXPECT_EQ(i32_neg1, i32_neg1.sext(63)); 2931 EXPECT_EQ(63U, i32_neg1.countl_one()); 2932 EXPECT_EQ(0U, i32_neg1.countr_zero()); 2933 EXPECT_EQ(63U, i32_neg1.popcount()); 2934 2935 EXPECT_EQ(APInt(32u, 0), APInt(0u, 0).sext(32)); 2936 EXPECT_EQ(APInt(64u, 0), APInt(0u, 0).sext(64)); 2937 } 2938 2939 TEST(APIntTest, trunc) { 2940 APInt val(32, 0xFFFFFFFF); 2941 EXPECT_EQ(0xFFFF, val.trunc(16)); 2942 EXPECT_EQ(0xFFFFFFFF, val.trunc(32)); 2943 } 2944 2945 TEST(APIntTest, concat) { 2946 APInt Int1(4, 0x1ULL); 2947 APInt Int3(4, 0x3ULL); 2948 2949 EXPECT_EQ(0x31, Int3.concat(Int1)); 2950 EXPECT_EQ(APInt(12, 0x313), Int3.concat(Int1).concat(Int3)); 2951 EXPECT_EQ(APInt(16, 0x3313), Int3.concat(Int3).concat(Int1).concat(Int3)); 2952 2953 APInt I64(64, 0x3ULL); 2954 EXPECT_EQ(I64, I64.concat(I64).lshr(64).trunc(64)); 2955 2956 APInt I65(65, 0x3ULL); 2957 APInt I0 = APInt::getZeroWidth(); 2958 EXPECT_EQ(I65, I65.concat(I0)); 2959 EXPECT_EQ(I65, I0.concat(I65)); 2960 } 2961 2962 TEST(APIntTest, multiply) { 2963 APInt i64(64, 1234); 2964 2965 EXPECT_EQ(7006652, i64 * 5678); 2966 EXPECT_EQ(7006652, 5678 * i64); 2967 2968 APInt i128 = APInt::getOneBitSet(128, 64); 2969 APInt i128_1234(128, 1234); 2970 i128_1234 <<= 64; 2971 EXPECT_EQ(i128_1234, i128 * 1234); 2972 EXPECT_EQ(i128_1234, 1234 * i128); 2973 2974 APInt i96 = APInt::getOneBitSet(96, 64); 2975 i96 *= ~0ULL; 2976 EXPECT_EQ(32U, i96.countl_one()); 2977 EXPECT_EQ(32U, i96.popcount()); 2978 EXPECT_EQ(64U, i96.countr_zero()); 2979 } 2980 2981 TEST(APIntOpsTest, Mulh) { 2982 2983 // Unsigned 2984 2985 // 32 bits 2986 APInt i32a(32, 0x0001'E235); 2987 APInt i32b(32, 0xF623'55AD); 2988 EXPECT_EQ(0x0001'CFA1, APIntOps::mulhu(i32a, i32b)); 2989 2990 // 64 bits 2991 APInt i64a(64, 0x1234'5678'90AB'CDEF); 2992 APInt i64b(64, 0xFEDC'BA09'8765'4321); 2993 EXPECT_EQ(0x121F'A000'A372'3A57, APIntOps::mulhu(i64a, i64b)); 2994 2995 // 128 bits 2996 APInt i128a(128, "1234567890ABCDEF1234567890ABCDEF", 16); 2997 APInt i128b(128, "FEDCBA0987654321FEDCBA0987654321", 16); 2998 APInt i128Res = APIntOps::mulhu(i128a, i128b); 2999 EXPECT_EQ(APInt(128, "121FA000A3723A57E68984312C3A8D7E", 16), i128Res); 3000 3001 // Signed 3002 3003 // 32 bits 3004 APInt i32c(32, 0x1234'5678); // +ve 3005 APInt i32d(32, 0x10AB'CDEF); // +ve 3006 APInt i32e(32, 0xFEDC'BA09); // -ve 3007 3008 EXPECT_EQ(0x012F'7D02, APIntOps::mulhs(i32c, i32d)); 3009 EXPECT_EQ(0xFFEB'4988, APIntOps::mulhs(i32c, i32e)); 3010 EXPECT_EQ(0x0001'4B68, APIntOps::mulhs(i32e, i32e)); 3011 3012 // 64 bits 3013 APInt i64c(64, 0x1234'5678'90AB'CDEF); // +ve 3014 APInt i64d(64, 0x1234'5678'90FE'DCBA); // +ve 3015 APInt i64e(64, 0xFEDC'BA09'8765'4321); // -ve 3016 3017 EXPECT_EQ(0x014B'66DC'328E'10C1, APIntOps::mulhs(i64c, i64d)); 3018 EXPECT_EQ(0xFFEB'4988'12C6'6C68, APIntOps::mulhs(i64c, i64e)); 3019 EXPECT_EQ(0x0001'4B68'2174'FA18, APIntOps::mulhs(i64e, i64e)); 3020 3021 // 128 bits 3022 APInt i128c(128, "1234567890ABCDEF1234567890ABCDEF", 16); // +ve 3023 APInt i128d(128, "1234567890FEDCBA1234567890FEDCBA", 16); // +ve 3024 APInt i128e(128, "FEDCBA0987654321FEDCBA0987654321", 16); // -ve 3025 3026 i128Res = APIntOps::mulhs(i128c, i128d); 3027 EXPECT_EQ(APInt(128, "14B66DC328E10C1FE303DF9EA0B2529", 16), i128Res); 3028 3029 i128Res = APIntOps::mulhs(i128c, i128e); 3030 EXPECT_EQ(APInt(128, "FFEB498812C66C68D4552DB89B8EBF8F", 16), i128Res); 3031 } 3032 3033 TEST(APIntTest, RoundingUDiv) { 3034 for (uint64_t Ai = 1; Ai <= 255; Ai++) { 3035 APInt A(8, Ai); 3036 APInt Zero(8, 0); 3037 EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::UP)); 3038 EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::DOWN)); 3039 EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::TOWARD_ZERO)); 3040 3041 for (uint64_t Bi = 1; Bi <= 255; Bi++) { 3042 APInt B(8, Bi); 3043 { 3044 APInt Quo = APIntOps::RoundingUDiv(A, B, APInt::Rounding::UP); 3045 auto Prod = Quo.zext(16) * B.zext(16); 3046 EXPECT_TRUE(Prod.uge(Ai)); 3047 if (Prod.ugt(Ai)) { 3048 EXPECT_TRUE(((Quo - 1).zext(16) * B.zext(16)).ult(Ai)); 3049 } 3050 } 3051 { 3052 APInt Quo = A.udiv(B); 3053 EXPECT_EQ(Quo, APIntOps::RoundingUDiv(A, B, APInt::Rounding::TOWARD_ZERO)); 3054 EXPECT_EQ(Quo, APIntOps::RoundingUDiv(A, B, APInt::Rounding::DOWN)); 3055 } 3056 } 3057 } 3058 } 3059 3060 TEST(APIntTest, RoundingSDiv) { 3061 for (int64_t Ai = -128; Ai <= 127; Ai++) { 3062 APInt A(8, Ai, true); 3063 3064 if (Ai != 0) { 3065 APInt Zero(8, 0); 3066 EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::UP)); 3067 EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::DOWN)); 3068 EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::TOWARD_ZERO)); 3069 } 3070 3071 for (int64_t Bi = -128; Bi <= 127; Bi++) { 3072 if (Bi == 0) 3073 continue; 3074 3075 APInt B(8, Bi, true); 3076 APInt QuoTowardZero = A.sdiv(B); 3077 { 3078 APInt Quo = APIntOps::RoundingSDiv(A, B, APInt::Rounding::UP); 3079 if (A.srem(B).isZero()) { 3080 EXPECT_EQ(QuoTowardZero, Quo); 3081 } else if (A.isNegative() != 3082 B.isNegative()) { // if the math quotient is negative. 3083 EXPECT_EQ(QuoTowardZero, Quo); 3084 } else { 3085 EXPECT_EQ(QuoTowardZero + 1, Quo); 3086 } 3087 } 3088 { 3089 APInt Quo = APIntOps::RoundingSDiv(A, B, APInt::Rounding::DOWN); 3090 if (A.srem(B).isZero()) { 3091 EXPECT_EQ(QuoTowardZero, Quo); 3092 } else if (A.isNegative() != 3093 B.isNegative()) { // if the math quotient is negative. 3094 EXPECT_EQ(QuoTowardZero - 1, Quo); 3095 } else { 3096 EXPECT_EQ(QuoTowardZero, Quo); 3097 } 3098 } 3099 EXPECT_EQ(QuoTowardZero, 3100 APIntOps::RoundingSDiv(A, B, APInt::Rounding::TOWARD_ZERO)); 3101 } 3102 } 3103 } 3104 3105 TEST(APIntTest, Average) { 3106 APInt A0(32, 0); 3107 APInt A2(32, 2); 3108 APInt A100(32, 100); 3109 APInt A101(32, 101); 3110 APInt A200(32, 200, false); 3111 APInt ApUMax = APInt::getMaxValue(32); 3112 3113 EXPECT_EQ(APInt(32, 150), APIntOps::avgFloorU(A100, A200)); 3114 EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A200, A2, APInt::Rounding::DOWN), 3115 APIntOps::avgFloorU(A100, A200)); 3116 EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A200, A2, APInt::Rounding::UP), 3117 APIntOps::avgCeilU(A100, A200)); 3118 EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A101, A2, APInt::Rounding::DOWN), 3119 APIntOps::avgFloorU(A100, A101)); 3120 EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A101, A2, APInt::Rounding::UP), 3121 APIntOps::avgCeilU(A100, A101)); 3122 EXPECT_EQ(A0, APIntOps::avgFloorU(A0, A0)); 3123 EXPECT_EQ(A0, APIntOps::avgCeilU(A0, A0)); 3124 EXPECT_EQ(ApUMax, APIntOps::avgFloorU(ApUMax, ApUMax)); 3125 EXPECT_EQ(ApUMax, APIntOps::avgCeilU(ApUMax, ApUMax)); 3126 EXPECT_EQ(APIntOps::RoundingUDiv(ApUMax, A2, APInt::Rounding::DOWN), 3127 APIntOps::avgFloorU(A0, ApUMax)); 3128 EXPECT_EQ(APIntOps::RoundingUDiv(ApUMax, A2, APInt::Rounding::UP), 3129 APIntOps::avgCeilU(A0, ApUMax)); 3130 3131 APInt Ap100(32, +100); 3132 APInt Ap101(32, +101); 3133 APInt Ap200(32, +200); 3134 APInt Am1(32, -1, true); 3135 APInt Am100(32, -100, true); 3136 APInt Am101(32, -101, true); 3137 APInt Am200(32, -200, true); 3138 APInt AmSMin = APInt::getSignedMinValue(32); 3139 APInt ApSMax = APInt::getSignedMaxValue(32); 3140 3141 EXPECT_EQ(APInt(32, +150), APIntOps::avgFloorS(Ap100, Ap200)); 3142 EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap200, A2, APInt::Rounding::DOWN), 3143 APIntOps::avgFloorS(Ap100, Ap200)); 3144 EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap200, A2, APInt::Rounding::UP), 3145 APIntOps::avgCeilS(Ap100, Ap200)); 3146 3147 EXPECT_EQ(APInt(32, -150, true), APIntOps::avgFloorS(Am100, Am200)); 3148 EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am200, A2, APInt::Rounding::DOWN), 3149 APIntOps::avgFloorS(Am100, Am200)); 3150 EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am200, A2, APInt::Rounding::UP), 3151 APIntOps::avgCeilS(Am100, Am200)); 3152 3153 EXPECT_EQ(APInt(32, +100), APIntOps::avgFloorS(Ap100, Ap101)); 3154 EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap101, A2, APInt::Rounding::DOWN), 3155 APIntOps::avgFloorS(Ap100, Ap101)); 3156 EXPECT_EQ(APInt(32, +101), APIntOps::avgCeilS(Ap100, Ap101)); 3157 EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap101, A2, APInt::Rounding::UP), 3158 APIntOps::avgCeilS(Ap100, Ap101)); 3159 3160 EXPECT_EQ(APInt(32, -101, true), APIntOps::avgFloorS(Am100, Am101)); 3161 EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am101, A2, APInt::Rounding::DOWN), 3162 APIntOps::avgFloorS(Am100, Am101)); 3163 EXPECT_EQ(APInt(32, -100, true), APIntOps::avgCeilS(Am100, Am101)); 3164 EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am101, A2, APInt::Rounding::UP), 3165 APIntOps::avgCeilS(Am100, Am101)); 3166 3167 EXPECT_EQ(AmSMin, APIntOps::avgFloorS(AmSMin, AmSMin)); 3168 EXPECT_EQ(AmSMin, APIntOps::avgCeilS(AmSMin, AmSMin)); 3169 3170 EXPECT_EQ(APIntOps::RoundingSDiv(AmSMin, A2, APInt::Rounding::DOWN), 3171 APIntOps::avgFloorS(A0, AmSMin)); 3172 EXPECT_EQ(APIntOps::RoundingSDiv(AmSMin, A2, APInt::Rounding::UP), 3173 APIntOps::avgCeilS(A0, AmSMin)); 3174 3175 EXPECT_EQ(A0, APIntOps::avgFloorS(A0, A0)); 3176 EXPECT_EQ(A0, APIntOps::avgCeilS(A0, A0)); 3177 3178 EXPECT_EQ(Am1, APIntOps::avgFloorS(AmSMin, ApSMax)); 3179 EXPECT_EQ(A0, APIntOps::avgCeilS(AmSMin, ApSMax)); 3180 3181 EXPECT_EQ(APIntOps::RoundingSDiv(ApSMax, A2, APInt::Rounding::DOWN), 3182 APIntOps::avgFloorS(A0, ApSMax)); 3183 EXPECT_EQ(APIntOps::RoundingSDiv(ApSMax, A2, APInt::Rounding::UP), 3184 APIntOps::avgCeilS(A0, ApSMax)); 3185 3186 EXPECT_EQ(ApSMax, APIntOps::avgFloorS(ApSMax, ApSMax)); 3187 EXPECT_EQ(ApSMax, APIntOps::avgCeilS(ApSMax, ApSMax)); 3188 } 3189 3190 TEST(APIntTest, umul_ov) { 3191 const std::pair<uint64_t, uint64_t> Overflows[] = { 3192 {0x8000000000000000, 2}, 3193 {0x5555555555555556, 3}, 3194 {4294967296, 4294967296}, 3195 {4294967295, 4294967298}, 3196 }; 3197 const std::pair<uint64_t, uint64_t> NonOverflows[] = { 3198 {0x7fffffffffffffff, 2}, 3199 {0x5555555555555555, 3}, 3200 {4294967295, 4294967297}, 3201 }; 3202 3203 bool Overflow; 3204 for (auto &X : Overflows) { 3205 APInt A(64, X.first); 3206 APInt B(64, X.second); 3207 (void)A.umul_ov(B, Overflow); 3208 EXPECT_TRUE(Overflow); 3209 } 3210 for (auto &X : NonOverflows) { 3211 APInt A(64, X.first); 3212 APInt B(64, X.second); 3213 (void)A.umul_ov(B, Overflow); 3214 EXPECT_FALSE(Overflow); 3215 } 3216 3217 for (unsigned Bits = 1; Bits <= 5; ++Bits) 3218 for (unsigned A = 0; A != 1u << Bits; ++A) 3219 for (unsigned B = 0; B != 1u << Bits; ++B) { 3220 APInt N1 = APInt(Bits, A), N2 = APInt(Bits, B); 3221 APInt Narrow = N1.umul_ov(N2, Overflow); 3222 APInt Wide = N1.zext(2 * Bits) * N2.zext(2 * Bits); 3223 EXPECT_EQ(Wide.trunc(Bits), Narrow); 3224 EXPECT_EQ(Narrow.zext(2 * Bits) != Wide, Overflow); 3225 } 3226 } 3227 3228 TEST(APIntTest, smul_ov) { 3229 for (unsigned Bits = 1; Bits <= 5; ++Bits) 3230 for (unsigned A = 0; A != 1u << Bits; ++A) 3231 for (unsigned B = 0; B != 1u << Bits; ++B) { 3232 bool Overflow; 3233 APInt N1 = APInt(Bits, A), N2 = APInt(Bits, B); 3234 APInt Narrow = N1.smul_ov(N2, Overflow); 3235 APInt Wide = N1.sext(2 * Bits) * N2.sext(2 * Bits); 3236 EXPECT_EQ(Wide.trunc(Bits), Narrow); 3237 EXPECT_EQ(Narrow.sext(2 * Bits) != Wide, Overflow); 3238 } 3239 } 3240 3241 TEST(APIntTest, sfloordiv_ov) { 3242 // int16 test overflow 3243 { 3244 using IntTy = int16_t; 3245 APInt divisor(8 * sizeof(IntTy), std::numeric_limits<IntTy>::lowest(), 3246 true); 3247 APInt dividend(8 * sizeof(IntTy), IntTy(-1), true); 3248 bool Overflow = false; 3249 (void)divisor.sfloordiv_ov(dividend, Overflow); 3250 EXPECT_TRUE(Overflow); 3251 } 3252 // int32 test overflow 3253 { 3254 using IntTy = int32_t; 3255 APInt divisor(8 * sizeof(IntTy), std::numeric_limits<IntTy>::lowest(), 3256 true); 3257 APInt dividend(8 * sizeof(IntTy), IntTy(-1), true); 3258 bool Overflow = false; 3259 (void)divisor.sfloordiv_ov(dividend, Overflow); 3260 EXPECT_TRUE(Overflow); 3261 } 3262 // int64 test overflow 3263 { 3264 using IntTy = int64_t; 3265 APInt divisor(8 * sizeof(IntTy), std::numeric_limits<IntTy>::lowest(), 3266 true); 3267 APInt dividend(8 * sizeof(IntTy), IntTy(-1), true); 3268 bool Overflow = false; 3269 (void)divisor.sfloordiv_ov(dividend, Overflow); 3270 EXPECT_TRUE(Overflow); 3271 } 3272 // test all of int8 3273 { 3274 bool Overflow = false; 3275 for (int i = -128; i < 128; ++i) { 3276 for (int j = -128; j < 128; ++j) { 3277 if (j == 0) 3278 continue; 3279 3280 int8_t a = static_cast<int8_t>(i); 3281 int8_t b = static_cast<int8_t>(j); 3282 3283 APInt divisor(8, a, true); 3284 APInt dividend(8, b, true); 3285 APInt quotient = divisor.sfloordiv_ov(dividend, Overflow); 3286 3287 if (i == -128 && j == -1) { 3288 EXPECT_TRUE(Overflow); 3289 continue; 3290 } 3291 3292 if (((i >= 0 && j > 0) || (i <= 0 && j < 0)) || 3293 (i % j == 0)) // if quotient >= 0 and remain == 0 floordiv 3294 // equivalent to div 3295 EXPECT_EQ(quotient.getSExtValue(), a / b); 3296 else 3297 EXPECT_EQ(quotient.getSExtValue(), a / b - 1); 3298 EXPECT_FALSE(Overflow); 3299 } 3300 } 3301 } 3302 } 3303 3304 TEST(APIntTest, SolveQuadraticEquationWrap) { 3305 // Verify that "Solution" is the first non-negative integer that solves 3306 // Ax^2 + Bx + C = "0 or overflow", i.e. that it is a correct solution 3307 // as calculated by SolveQuadraticEquationWrap. 3308 auto Validate = [] (int A, int B, int C, unsigned Width, int Solution) { 3309 int Mask = (1 << Width) - 1; 3310 3311 // Solution should be non-negative. 3312 EXPECT_GE(Solution, 0); 3313 3314 auto OverflowBits = [] (int64_t V, unsigned W) { 3315 return V & -(1 << W); 3316 }; 3317 3318 int64_t Over0 = OverflowBits(C, Width); 3319 3320 auto IsZeroOrOverflow = [&] (int X) { 3321 int64_t ValueAtX = A*X*X + B*X + C; 3322 int64_t OverX = OverflowBits(ValueAtX, Width); 3323 return (ValueAtX & Mask) == 0 || OverX != Over0; 3324 }; 3325 3326 auto EquationToString = [&] (const char *X_str) { 3327 return (Twine(A) + Twine(X_str) + Twine("^2 + ") + Twine(B) + 3328 Twine(X_str) + Twine(" + ") + Twine(C) + Twine(", bitwidth: ") + 3329 Twine(Width)).str(); 3330 }; 3331 3332 auto IsSolution = [&] (const char *X_str, int X) { 3333 if (IsZeroOrOverflow(X)) 3334 return ::testing::AssertionSuccess() 3335 << X << " is a solution of " << EquationToString(X_str); 3336 return ::testing::AssertionFailure() 3337 << X << " is not an expected solution of " 3338 << EquationToString(X_str); 3339 }; 3340 3341 auto IsNotSolution = [&] (const char *X_str, int X) { 3342 if (!IsZeroOrOverflow(X)) 3343 return ::testing::AssertionSuccess() 3344 << X << " is not a solution of " << EquationToString(X_str); 3345 return ::testing::AssertionFailure() 3346 << X << " is an unexpected solution of " 3347 << EquationToString(X_str); 3348 }; 3349 3350 // This is the important part: make sure that there is no solution that 3351 // is less than the calculated one. 3352 if (Solution > 0) { 3353 for (int X = 1; X < Solution-1; ++X) 3354 EXPECT_PRED_FORMAT1(IsNotSolution, X); 3355 } 3356 3357 // Verify that the calculated solution is indeed a solution. 3358 EXPECT_PRED_FORMAT1(IsSolution, Solution); 3359 }; 3360 3361 // Generate all possible quadratic equations with Width-bit wide integer 3362 // coefficients, get the solution from SolveQuadraticEquationWrap, and 3363 // verify that the solution is correct. 3364 auto Iterate = [&] (unsigned Width) { 3365 assert(1 < Width && Width < 32); 3366 int Low = -(1 << (Width-1)); 3367 int High = (1 << (Width-1)); 3368 3369 for (int A = Low; A != High; ++A) { 3370 if (A == 0) 3371 continue; 3372 for (int B = Low; B != High; ++B) { 3373 for (int C = Low; C != High; ++C) { 3374 std::optional<APInt> S = APIntOps::SolveQuadraticEquationWrap( 3375 APInt(Width, A, true), APInt(Width, B, true), 3376 APInt(Width, C, true), Width); 3377 if (S) 3378 Validate(A, B, C, Width, S->getSExtValue()); 3379 } 3380 } 3381 } 3382 }; 3383 3384 // Test all widths in [2..6]. 3385 for (unsigned i = 2; i <= 6; ++i) 3386 Iterate(i); 3387 } 3388 3389 TEST(APIntTest, MultiplicativeInverseExaustive) { 3390 for (unsigned BitWidth = 1; BitWidth <= 8; ++BitWidth) { 3391 for (unsigned Value = 1; Value < (1u << BitWidth); Value += 2) { 3392 // Multiplicative inverse exists for all odd numbers. 3393 APInt V = APInt(BitWidth, Value); 3394 EXPECT_EQ(V * V.multiplicativeInverse(), 1); 3395 } 3396 } 3397 } 3398 3399 TEST(APIntTest, GetMostSignificantDifferentBit) { 3400 EXPECT_EQ(APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 0)), 3401 std::nullopt); 3402 EXPECT_EQ( 3403 APIntOps::GetMostSignificantDifferentBit(APInt(8, 42), APInt(8, 42)), 3404 std::nullopt); 3405 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 1)), 3406 0u); 3407 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 2)), 3408 1u); 3409 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 3)), 3410 1u); 3411 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 0)), 3412 0u); 3413 EXPECT_EQ(APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 1)), 3414 std::nullopt); 3415 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 2)), 3416 1u); 3417 EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 3)), 3418 1u); 3419 EXPECT_EQ( 3420 *APIntOps::GetMostSignificantDifferentBit(APInt(8, 42), APInt(8, 112)), 3421 6u); 3422 } 3423 3424 TEST(APIntTest, GetMostSignificantDifferentBitExaustive) { 3425 auto GetHighestDifferentBitBruteforce = 3426 [](const APInt &V0, const APInt &V1) -> std::optional<unsigned> { 3427 assert(V0.getBitWidth() == V1.getBitWidth() && "Must have same bitwidth"); 3428 if (V0 == V1) 3429 return std::nullopt; // Bitwise identical. 3430 // There is a mismatch. Let's find the most significant different bit. 3431 for (int Bit = V0.getBitWidth() - 1; Bit >= 0; --Bit) { 3432 if (V0[Bit] == V1[Bit]) 3433 continue; 3434 return Bit; 3435 } 3436 llvm_unreachable("Must have found bit mismatch."); 3437 }; 3438 3439 for (unsigned BitWidth = 1; BitWidth <= 8; ++BitWidth) { 3440 for (unsigned V0 = 0; V0 < (1u << BitWidth); ++V0) { 3441 for (unsigned V1 = 0; V1 < (1u << BitWidth); ++V1) { 3442 APInt A = APInt(BitWidth, V0); 3443 APInt B = APInt(BitWidth, V1); 3444 3445 auto Bit = APIntOps::GetMostSignificantDifferentBit(A, B); 3446 EXPECT_EQ(Bit, GetHighestDifferentBitBruteforce(A, B)); 3447 3448 if (!Bit) 3449 EXPECT_EQ(A, B); 3450 else { 3451 EXPECT_NE(A, B); 3452 for (unsigned NumLowBits = 0; NumLowBits <= BitWidth; ++NumLowBits) { 3453 APInt Adash = A; 3454 Adash.clearLowBits(NumLowBits); 3455 APInt Bdash = B; 3456 Bdash.clearLowBits(NumLowBits); 3457 // Clearing only low bits up to and including *Bit is sufficient 3458 // to make values equal. 3459 if (NumLowBits >= 1 + *Bit) 3460 EXPECT_EQ(Adash, Bdash); 3461 else 3462 EXPECT_NE(Adash, Bdash); 3463 } 3464 } 3465 } 3466 } 3467 } 3468 } 3469 3470 TEST(APIntTest, SignbitZeroChecks) { 3471 EXPECT_TRUE(APInt(8, -1, true).isNegative()); 3472 EXPECT_FALSE(APInt(8, -1, true).isNonNegative()); 3473 EXPECT_FALSE(APInt(8, -1, true).isStrictlyPositive()); 3474 EXPECT_TRUE(APInt(8, -1, true).isNonPositive()); 3475 3476 EXPECT_FALSE(APInt(8, 0).isNegative()); 3477 EXPECT_TRUE(APInt(8, 0).isNonNegative()); 3478 EXPECT_FALSE(APInt(8, 0).isStrictlyPositive()); 3479 EXPECT_TRUE(APInt(8, 0).isNonPositive()); 3480 3481 EXPECT_FALSE(APInt(8, 1).isNegative()); 3482 EXPECT_TRUE(APInt(8, 1).isNonNegative()); 3483 EXPECT_TRUE(APInt(8, 1).isStrictlyPositive()); 3484 EXPECT_FALSE(APInt(8, 1).isNonPositive()); 3485 } 3486 3487 TEST(APIntTest, ZeroWidth) { 3488 // Zero width Constructors. 3489 auto ZW = APInt::getZeroWidth(); 3490 EXPECT_EQ(0U, ZW.getBitWidth()); 3491 EXPECT_EQ(0U, APInt(0, ArrayRef<uint64_t>({0, 1, 2})).getBitWidth()); 3492 EXPECT_EQ(0U, APInt(0, "0", 10).getBitWidth()); 3493 EXPECT_EQ(0U, APInt::getAllOnes(0).getBitWidth()); 3494 3495 // Default constructor is single bit wide. 3496 EXPECT_EQ(1U, APInt().getBitWidth()); 3497 3498 // Copy ctor (move is down below). 3499 APInt ZW2(ZW); 3500 EXPECT_EQ(0U, ZW2.getBitWidth()); 3501 // Assignment 3502 ZW = ZW2; 3503 EXPECT_EQ(0U, ZW.getBitWidth()); 3504 3505 // Methods like getLowBitsSet work with zero bits. 3506 EXPECT_EQ(0U, APInt::getLowBitsSet(0, 0).getBitWidth()); 3507 EXPECT_EQ(0U, APInt::getSplat(0, ZW).getBitWidth()); 3508 EXPECT_EQ(0U, APInt(4, 10).extractBits(0, 2).getBitWidth()); 3509 EXPECT_EQ(0U, APInt(4, 10).extractBitsAsZExtValue(0, 2)); 3510 3511 // Logical operators. 3512 ZW |= ZW2; 3513 ZW &= ZW2; 3514 ZW ^= ZW2; 3515 ZW |= 42; // These ignore high bits of the literal. 3516 ZW &= 42; 3517 ZW ^= 42; 3518 EXPECT_EQ(1, ZW.isIntN(0)); 3519 3520 // Modulo Arithmetic. Divide/Rem aren't defined on division by zero, so they 3521 // aren't supported. 3522 ZW += ZW2; 3523 ZW -= ZW2; 3524 ZW *= ZW2; 3525 3526 // Logical Shifts and rotates, the amount must be <= bitwidth. 3527 ZW <<= 0; 3528 ZW.lshrInPlace(0); 3529 (void)ZW.rotl(0); 3530 (void)ZW.rotr(0); 3531 3532 // Comparisons. 3533 EXPECT_EQ(1, ZW == ZW); 3534 EXPECT_EQ(0, ZW != ZW); 3535 EXPECT_EQ(0, ZW.ult(ZW)); 3536 3537 // Mutations. 3538 ZW.setBitsWithWrap(0, 0); 3539 ZW.setBits(0, 0); 3540 ZW.clearAllBits(); 3541 ZW.flipAllBits(); 3542 3543 // Leading, trailing, ctpop, etc 3544 EXPECT_EQ(0U, ZW.countl_zero()); 3545 EXPECT_EQ(0U, ZW.countl_one()); 3546 EXPECT_EQ(0U, ZW.popcount()); 3547 EXPECT_EQ(0U, ZW.reverseBits().getBitWidth()); 3548 EXPECT_EQ(0U, ZW.getHiBits(0).getBitWidth()); 3549 EXPECT_EQ(0U, ZW.getLoBits(0).getBitWidth()); 3550 EXPECT_EQ(0, ZW.zext(4)); 3551 EXPECT_EQ(0U, APInt(4, 3).trunc(0).getBitWidth()); 3552 EXPECT_TRUE(ZW.isAllOnes()); 3553 3554 // Zero extension. 3555 EXPECT_EQ(0U, ZW.getZExtValue()); 3556 3557 SmallString<42> STR; 3558 ZW.toStringUnsigned(STR); 3559 EXPECT_EQ("0", STR); 3560 3561 // Move ctor (keep at the end of the method since moves are destructive). 3562 APInt MZW1(std::move(ZW)); 3563 EXPECT_EQ(0U, MZW1.getBitWidth()); 3564 // Move Assignment 3565 MZW1 = std::move(ZW2); 3566 EXPECT_EQ(0U, MZW1.getBitWidth()); 3567 } 3568 3569 TEST(APIntTest, ScaleBitMask) { 3570 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x00), 8), APInt(8, 0x00)); 3571 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x01), 8), APInt(8, 0x0F)); 3572 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x02), 8), APInt(8, 0xF0)); 3573 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x03), 8), APInt(8, 0xFF)); 3574 3575 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0x00), 4), APInt(4, 0x00)); 3576 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xFF), 4), APInt(4, 0x0F)); 3577 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xE4), 4), APInt(4, 0x0E)); 3578 3579 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0x00), 8), APInt(8, 0x00)); 3580 3581 EXPECT_EQ(APIntOps::ScaleBitMask(APInt::getZero(1024), 4096), 3582 APInt::getZero(4096)); 3583 EXPECT_EQ(APIntOps::ScaleBitMask(APInt::getAllOnes(4096), 256), 3584 APInt::getAllOnes(256)); 3585 EXPECT_EQ(APIntOps::ScaleBitMask(APInt::getOneBitSet(4096, 32), 256), 3586 APInt::getOneBitSet(256, 2)); 3587 3588 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x00), 8, true), APInt(8, 0x00)); 3589 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x01), 8, true), APInt(8, 0x0F)); 3590 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x02), 8, true), APInt(8, 0xF0)); 3591 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x03), 8, true), APInt(8, 0xFF)); 3592 3593 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0x00), 4, true), APInt(4, 0x00)); 3594 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xFF), 4, true), APInt(4, 0x0F)); 3595 EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xE4), 4, true), APInt(4, 0x08)); 3596 } 3597 3598 TEST(APIntTest, DenseMap) { 3599 DenseMap<APInt, int> Map; 3600 APInt ZeroWidthInt(0, 0, false); 3601 Map.insert({ZeroWidthInt, 0}); 3602 Map.find(ZeroWidthInt); 3603 } 3604 3605 TEST(APIntTest, TryExt) { 3606 APInt small(32, 42); 3607 APInt large(128, {0xffff, 0xffff}); 3608 ASSERT_TRUE(small.tryZExtValue().has_value()); 3609 ASSERT_TRUE(small.trySExtValue().has_value()); 3610 ASSERT_FALSE(large.tryZExtValue().has_value()); 3611 ASSERT_FALSE(large.trySExtValue().has_value()); 3612 ASSERT_EQ(small.trySExtValue().value_or(41), 42); 3613 ASSERT_EQ(large.trySExtValue().value_or(41), 41); 3614 3615 APInt negOne32(32, 0); 3616 negOne32.setAllBits(); 3617 ASSERT_EQ(negOne32.trySExtValue().value_or(42), -1); 3618 APInt negOne64(64, 0); 3619 negOne64.setAllBits(); 3620 ASSERT_EQ(negOne64.trySExtValue().value_or(42), -1); 3621 APInt negOne128(128, 0); 3622 negOne128.setAllBits(); 3623 ASSERT_EQ(negOne128.trySExtValue().value_or(42), -1); 3624 ASSERT_EQ(42, APInt(128, -1).trySExtValue().value_or(42)); 3625 } 3626 3627 } // end anonymous namespace 3628