brintos / llvm-project-archived public Read only

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-exception6//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 21using namespace llvm;22 23namespace {24 25TEST(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 == 033TEST(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 == 141TEST(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 == 102448TEST(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 == 2756TEST(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 == SignedMaxValue64TEST(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 == MaxValue71TEST(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 == 078TEST(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 == SignedMinValue85TEST(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 == MaxValue92TEST(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 == 0100TEST(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 107TEST(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 112TEST(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 127TEST(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 138TEST(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 158TEST(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 176TEST(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 Test225  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 258TEST(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 289TEST(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  // And329  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  // Or339  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  // Xor349  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  // sdivrem395  {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 423TEST(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 461TEST(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 535TEST(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 555TEST(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 588TEST(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 616TEST(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    0x305F341CA00B613DULL646  };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 668TEST(APIntTest, rvalue_arithmetic) {669  // Test all combinations of lvalue/rvalue lhs/rhs of add/sub670 671  // Lamdba to return an APInt by value, but also provide the raw value of the672  // 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 = 2689    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 constants705    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 constants712    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...0001723    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 constants743    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 constants750    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 = 1761    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 constants777    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 constants784    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 = 0x2795    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 constants817    // 0x100...0001 - 0x2 = 0x0,FFFF...FFFF818    APInt SubLK = HighOneLowOne - 2;819    EXPECT_EQ(SubLK, AllOnes);820 821    // 2 - (-1) = 3822    APInt SubKL = 2 - MinusOne;823    EXPECT_EQ(SubKL, Three);824 825    // RValue's and constants826    // 0x100...0001 - 0x2 = 0x0,FFFF...FFFF827    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 837TEST(APIntTest, rvalue_bitwise) {838  // Test all combinations of lvalue/rvalue lhs/rhs of and/or/xor839 840  // Lamdba to return an APInt by value, but also provide the raw value of the841  // 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 = 8856    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 constants872    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 constants879    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 = 14890    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 constants906    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 constants913    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 = 6924    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 constants940    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 constants947    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 957TEST(APIntTest, rvalue_invert) {958  // Lamdba to return an APInt by value, but also provide the raw value of the959  // 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 = -2973    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) / a983void testDiv(APInt a, APInt b, APInt c) {984  ASSERT_TRUE(a.uge(b)); // Must: a >= b985  ASSERT_TRUE(a.ugt(c)); // Must: a > c986 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 case1005    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 1022TEST(APIntTest, divrem_big1) {1023  // Tests KnuthDiv rare step D61024  testDiv({256, "1ffffffffffffffff", 16},1025          {256, "1ffffffffffffffff", 16},1026          {256, 0});1027}1028 1029TEST(APIntTest, divrem_big2) {1030  // Tests KnuthDiv rare step D61031  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 1043TEST(APIntTest, divrem_big3) {1044  // Tests KnuthDiv case without shift1045  testDiv({256, "80000001ffffffffffffffff", 16},1046          {256, "ffffffffffffff0000000", 16},1047          {256, 4219});1048}1049 1050TEST(APIntTest, divrem_big4) {1051  // Tests heap allocation in divide() enfoced by huge numbers1052  testDiv(APInt{4096, 5}.shl(2001),1053          APInt{4096, 1}.shl(2000),1054          APInt{4096, 4219*13});1055}1056 1057TEST(APIntTest, divrem_big5) {1058  // Tests one word divisor case of divide()1059  testDiv(APInt{1024, 19}.shl(811),1060          APInt{1024, 4356013}, // one word1061          APInt{1024, 1});1062}1063 1064TEST(APIntTest, divrem_big6) {1065  // Tests some rare "borrow" cases in D4 step1066  testDiv(APInt{512, "ffffffffffffffff00000000000000000000000001", 16},1067          APInt{512, "10000000000000001000000000000001", 16},1068          APInt{512, "10000000000000000000000000000000", 16});1069}1070 1071TEST(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 1078void 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  else1099    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  else1106    EXPECT_EQ(c, sr);1107}1108 1109TEST(APIntTest, divremuint) {1110  // Single word APInt1111  testDiv(APInt{64, 9},1112          2,1113          APInt{64, 1});1114 1115  // Single word negative APInt1116  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 dividend1131  testDiv(APInt{1024, 19}.shl(811),1132          4356013, // one word1133          APInt{1024, 1});1134}1135 1136TEST(APIntTest, divrem_simple) {1137  // Test simple cases.1138  APInt A(65, 2), B(65, 2);1139  APInt Q, R;1140 1141  // X / X1142  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 / X1150  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 / 11159  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 1168TEST(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 1251TEST(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 1332TEST(APIntTest, FromArray) {1333  EXPECT_EQ(APInt(32, uint64_t(1)), APInt(32, ArrayRef<uint64_t>(1)));1334}1335 1336TEST(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 1356TEST(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 1376TEST(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 1413TEST(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 1433TEST(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 separators1454  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 separators1508  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 1526TEST(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_TEST1539#ifndef NDEBUG1540TEST(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#endif1551#endif1552 1553TEST(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 1565TEST(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 1645TEST(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 1655TEST(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 1721TEST(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    0x305F341CA00B613DULL1736  };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 1746TEST(APIntTest, LargeAPIntConstruction) {1747  // Check that we can properly construct very large APInt. It is very1748  // 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 1754TEST(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 such1796  // 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 1801TEST(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 1841TEST(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 1859TEST(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 1906TEST(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 1916TEST(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 1936TEST(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 1962TEST(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 which1982// does self-move on some platforms.1983#ifdef EXPENSIVE_CHECKS1984#if defined(__clang__)1985// Disable the pragma warning from versions of Clang without -Wself-move1986#pragma clang diagnostic push1987#pragma clang diagnostic ignored "-Wunknown-pragmas"1988// Disable the warning that triggers on exactly what is being tested.1989#pragma clang diagnostic push1990#pragma clang diagnostic ignored "-Wself-move"1991#endif1992TEST(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 pop2010#pragma clang diagnostic pop2011#endif2012#endif // EXPENSIVE_CHECKS2013 2014TEST(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 2035TEST(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 2077TEST(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 2134TEST(APIntTest, insertBitsUInt64) {2135  // Tests cloned from insertBits but adapted to the numBits <= 64 constraint2136  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 2192TEST(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 2236TEST(APIntTest, extractBitsAsZExtValue) {2237  // Tests based on extractBits2238  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 2263TEST(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 2273TEST(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 2291TEST(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 2333TEST(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 2343TEST(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 2353TEST(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 2409TEST(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 2474TEST(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 2485TEST(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 2523TEST(APIntTest, clearBits) {2524  APInt i32 = APInt::getAllOnes(32);2525  i32.clearBits(1, 3);2526  EXPECT_EQ(1u, i32.countr_one());2527  EXPECT_EQ(0u, i32.countr_zero());2528  EXPECT_EQ(32u, i32.getActiveBits());2529  EXPECT_EQ(0u, i32.countl_zero());2530  EXPECT_EQ(29u, i32.countl_one());2531  EXPECT_EQ(30u, i32.popcount());2532 2533  i32.clearBits(15, 15);2534  EXPECT_EQ(1u, i32.countr_one());2535  EXPECT_EQ(0u, i32.countr_zero());2536  EXPECT_EQ(32u, i32.getActiveBits());2537  EXPECT_EQ(0u, i32.countl_zero());2538  EXPECT_EQ(29u, i32.countl_one());2539  EXPECT_EQ(30u, i32.popcount());2540 2541  i32.clearBits(28, 31);2542  EXPECT_EQ(1u, i32.countr_one());2543  EXPECT_EQ(0u, i32.countr_zero());2544  EXPECT_EQ(32u, i32.getActiveBits());2545  EXPECT_EQ(0u, i32.countl_zero());2546  EXPECT_EQ(1u, i32.countl_one());2547  EXPECT_EQ(27u, i32.popcount());2548  EXPECT_EQ(APInt(32, "8FFFFFF9", 16), i32);2549 2550  APInt i256 = APInt::getAllOnes(256);2551  i256.clearBits(10, 250);2552  EXPECT_EQ(10u, i256.countr_one());2553  EXPECT_EQ(0u, i256.countr_zero());2554  EXPECT_EQ(256u, i256.getActiveBits());2555  EXPECT_EQ(0u, i256.countl_zero());2556  EXPECT_EQ(6u, i256.countl_one());2557  EXPECT_EQ(16u, i256.popcount());2558 2559  APInt i299 = APInt::getAllOnes(299);2560  i299.clearBits(240, 250);2561  EXPECT_EQ(240u, i299.countr_one());2562  EXPECT_EQ(0u, i299.countr_zero());2563  EXPECT_EQ(299u, i299.getActiveBits());2564  EXPECT_EQ(0u, i299.countl_zero());2565  EXPECT_EQ(49u, i299.countl_one());2566  EXPECT_EQ(289u, i299.popcount());2567 2568  APInt i311 = APInt::getAllOnes(311);2569  i311.clearBits(33, 99);2570  EXPECT_EQ(33u, i311.countr_one());2571  EXPECT_EQ(0u, i311.countr_zero());2572  EXPECT_EQ(311u, i311.getActiveBits());2573  EXPECT_EQ(0u, i311.countl_zero());2574  EXPECT_EQ(212u, i311.countl_one());2575  EXPECT_EQ(245u, i311.popcount());2576 2577  APInt i64hi32 = APInt::getAllOnes(64);2578  i64hi32.clearBits(0, 32);2579  EXPECT_EQ(32u, i64hi32.countl_one());2580  EXPECT_EQ(0u, i64hi32.countl_zero());2581  EXPECT_EQ(64u, i64hi32.getActiveBits());2582  EXPECT_EQ(32u, i64hi32.countr_zero());2583  EXPECT_EQ(0u, i64hi32.countr_one());2584  EXPECT_EQ(32u, i64hi32.popcount());2585 2586  i64hi32 = APInt::getAllOnes(64);2587  i64hi32.clearBits(32, 64);2588  EXPECT_EQ(32u, i64hi32.countr_one());2589  EXPECT_EQ(0u, i64hi32.countr_zero());2590  EXPECT_EQ(32u, i64hi32.getActiveBits());2591  EXPECT_EQ(32u, i64hi32.countl_zero());2592  EXPECT_EQ(0u, i64hi32.countl_one());2593  EXPECT_EQ(32u, i64hi32.popcount());2594}2595 2596TEST(APIntTest, getLoBits) {2597  APInt i32(32, 0xfa);2598  i32.setHighBits(1);2599  EXPECT_EQ(0xa, i32.getLoBits(4));2600  APInt i128(128, 0xfa);2601  i128.setHighBits(1);2602  EXPECT_EQ(0xa, i128.getLoBits(4));2603}2604 2605TEST(APIntTest, getHiBits) {2606  APInt i32(32, 0xfa);2607  i32.setHighBits(2);2608  EXPECT_EQ(0xc, i32.getHiBits(4));2609  APInt i128(128, 0xfa);2610  i128.setHighBits(2);2611  EXPECT_EQ(0xc, i128.getHiBits(4));2612}2613 2614TEST(APIntTest, clearLowBits) {2615  APInt i64hi32 = APInt::getAllOnes(64);2616  i64hi32.clearLowBits(32);2617  EXPECT_EQ(32u, i64hi32.countl_one());2618  EXPECT_EQ(0u, i64hi32.countl_zero());2619  EXPECT_EQ(64u, i64hi32.getActiveBits());2620  EXPECT_EQ(32u, i64hi32.countr_zero());2621  EXPECT_EQ(0u, i64hi32.countr_one());2622  EXPECT_EQ(32u, i64hi32.popcount());2623 2624  APInt i128hi64 = APInt::getAllOnes(128);2625  i128hi64.clearLowBits(64);2626  EXPECT_EQ(64u, i128hi64.countl_one());2627  EXPECT_EQ(0u, i128hi64.countl_zero());2628  EXPECT_EQ(128u, i128hi64.getActiveBits());2629  EXPECT_EQ(64u, i128hi64.countr_zero());2630  EXPECT_EQ(0u, i128hi64.countr_one());2631  EXPECT_EQ(64u, i128hi64.popcount());2632 2633  APInt i128hi24 = APInt::getAllOnes(128);2634  i128hi24.clearLowBits(104);2635  EXPECT_EQ(24u, i128hi24.countl_one());2636  EXPECT_EQ(0u, i128hi24.countl_zero());2637  EXPECT_EQ(128u, i128hi24.getActiveBits());2638  EXPECT_EQ(104u, i128hi24.countr_zero());2639  EXPECT_EQ(0u, i128hi24.countr_one());2640  EXPECT_EQ(24u, i128hi24.popcount());2641 2642  APInt i128hi104 = APInt::getAllOnes(128);2643  i128hi104.clearLowBits(24);2644  EXPECT_EQ(104u, i128hi104.countl_one());2645  EXPECT_EQ(0u, i128hi104.countl_zero());2646  EXPECT_EQ(128u, i128hi104.getActiveBits());2647  EXPECT_EQ(24u, i128hi104.countr_zero());2648  EXPECT_EQ(0u, i128hi104.countr_one());2649  EXPECT_EQ(104u, i128hi104.popcount());2650 2651  APInt i128hi0 = APInt::getAllOnes(128);2652  i128hi0.clearLowBits(128);2653  EXPECT_EQ(0u, i128hi0.countl_one());2654  EXPECT_EQ(128u, i128hi0.countl_zero());2655  EXPECT_EQ(0u, i128hi0.getActiveBits());2656  EXPECT_EQ(128u, i128hi0.countr_zero());2657  EXPECT_EQ(0u, i128hi0.countr_one());2658  EXPECT_EQ(0u, i128hi0.popcount());2659 2660  APInt i80hi1 = APInt::getAllOnes(80);2661  i80hi1.clearLowBits(79);2662  EXPECT_EQ(1u, i80hi1.countl_one());2663  EXPECT_EQ(0u, i80hi1.countl_zero());2664  EXPECT_EQ(80u, i80hi1.getActiveBits());2665  EXPECT_EQ(79u, i80hi1.countr_zero());2666  EXPECT_EQ(0u, i80hi1.countr_one());2667  EXPECT_EQ(1u, i80hi1.popcount());2668 2669  APInt i32hi16 = APInt::getAllOnes(32);2670  i32hi16.clearLowBits(16);2671  EXPECT_EQ(16u, i32hi16.countl_one());2672  EXPECT_EQ(0u, i32hi16.countl_zero());2673  EXPECT_EQ(32u, i32hi16.getActiveBits());2674  EXPECT_EQ(16u, i32hi16.countr_zero());2675  EXPECT_EQ(0u, i32hi16.countr_one());2676  EXPECT_EQ(16u, i32hi16.popcount());2677}2678 2679TEST(APIntTest, clearHighBits) {2680  APInt i64hi32 = APInt::getAllOnes(64);2681  i64hi32.clearHighBits(32);2682  EXPECT_EQ(32u, i64hi32.countr_one());2683  EXPECT_EQ(0u, i64hi32.countr_zero());2684  EXPECT_EQ(32u, i64hi32.getActiveBits());2685  EXPECT_EQ(32u, i64hi32.countl_zero());2686  EXPECT_EQ(0u, i64hi32.countl_one());2687  EXPECT_EQ(32u, i64hi32.popcount());2688 2689  APInt i128hi64 = APInt::getAllOnes(128);2690  i128hi64.clearHighBits(64);2691  EXPECT_EQ(64u, i128hi64.countr_one());2692  EXPECT_EQ(0u, i128hi64.countr_zero());2693  EXPECT_EQ(64u, i128hi64.getActiveBits());2694  EXPECT_EQ(64u, i128hi64.countl_zero());2695  EXPECT_EQ(0u, i128hi64.countl_one());2696  EXPECT_EQ(64u, i128hi64.popcount());2697 2698  APInt i128hi24 = APInt::getAllOnes(128);2699  i128hi24.clearHighBits(104);2700  EXPECT_EQ(24u, i128hi24.countr_one());2701  EXPECT_EQ(0u, i128hi24.countr_zero());2702  EXPECT_EQ(24u, i128hi24.getActiveBits());2703  EXPECT_EQ(104u, i128hi24.countl_zero());2704  EXPECT_EQ(0u, i128hi24.countl_one());2705  EXPECT_EQ(24u, i128hi24.popcount());2706 2707  APInt i128hi104 = APInt::getAllOnes(128);2708  i128hi104.clearHighBits(24);2709  EXPECT_EQ(104u, i128hi104.countr_one());2710  EXPECT_EQ(0u, i128hi104.countr_zero());2711  EXPECT_EQ(104u, i128hi104.getActiveBits());2712  EXPECT_EQ(24u, i128hi104.countl_zero());2713  EXPECT_EQ(0u, i128hi104.countl_one());2714  EXPECT_EQ(104u, i128hi104.popcount());2715 2716  APInt i128hi0 = APInt::getAllOnes(128);2717  i128hi0.clearHighBits(128);2718  EXPECT_EQ(0u, i128hi0.countr_one());2719  EXPECT_EQ(128u, i128hi0.countr_zero());2720  EXPECT_EQ(0u, i128hi0.getActiveBits());2721  EXPECT_EQ(128u, i128hi0.countl_zero());2722  EXPECT_EQ(0u, i128hi0.countl_one());2723  EXPECT_EQ(0u, i128hi0.popcount());2724 2725  APInt i80hi1 = APInt::getAllOnes(80);2726  i80hi1.clearHighBits(79);2727  EXPECT_EQ(1u, i80hi1.countr_one());2728  EXPECT_EQ(0u, i80hi1.countr_zero());2729  EXPECT_EQ(1u, i80hi1.getActiveBits());2730  EXPECT_EQ(79u, i80hi1.countl_zero());2731  EXPECT_EQ(0u, i80hi1.countl_one());2732  EXPECT_EQ(1u, i80hi1.popcount());2733 2734  APInt i32hi16 = APInt::getAllOnes(32);2735  i32hi16.clearHighBits(16);2736  EXPECT_EQ(16u, i32hi16.countr_one());2737  EXPECT_EQ(0u, i32hi16.countr_zero());2738  EXPECT_EQ(16u, i32hi16.getActiveBits());2739  EXPECT_EQ(16u, i32hi16.countl_zero());2740  EXPECT_EQ(0u, i32hi16.countl_one());2741  EXPECT_EQ(16u, i32hi16.popcount());2742}2743 2744TEST(APIntTest, abds) {2745  using APIntOps::abds;2746 2747  APInt MaxU1(1, 1, false);2748  APInt MinU1(1, 0, false);2749  EXPECT_EQ(1u, abds(MaxU1, MinU1).getZExtValue());2750  EXPECT_EQ(1u, abds(MinU1, MaxU1).getZExtValue());2751 2752  APInt MaxU4(4, 15, false);2753  APInt MinU4(4, 0, false);2754  EXPECT_EQ(1, abds(MaxU4, MinU4).getSExtValue());2755  EXPECT_EQ(1, abds(MinU4, MaxU4).getSExtValue());2756 2757  APInt MaxS8(8, 127, true);2758  APInt MinS8(8, -128, true);2759  EXPECT_EQ(-1, abds(MaxS8, MinS8).getSExtValue());2760  EXPECT_EQ(-1, abds(MinS8, MaxS8).getSExtValue());2761 2762  APInt MaxU16(16, 65535, false);2763  APInt MinU16(16, 0, false);2764  EXPECT_EQ(1, abds(MaxU16, MinU16).getSExtValue());2765  EXPECT_EQ(1, abds(MinU16, MaxU16).getSExtValue());2766 2767  APInt MaxS16(16, 32767, true);2768  APInt MinS16(16, -32768, true);2769  APInt ZeroS16(16, 0, true);2770  EXPECT_EQ(-1, abds(MaxS16, MinS16).getSExtValue());2771  EXPECT_EQ(-1, abds(MinS16, MaxS16).getSExtValue());2772  EXPECT_EQ(32768u, abds(ZeroS16, MinS16));2773  EXPECT_EQ(32768u, abds(MinS16, ZeroS16));2774  EXPECT_EQ(32767u, abds(ZeroS16, MaxS16));2775  EXPECT_EQ(32767u, abds(MaxS16, ZeroS16));2776}2777 2778TEST(APIntTest, abdu) {2779  using APIntOps::abdu;2780 2781  APInt MaxU1(1, 1, false);2782  APInt MinU1(1, 0, false);2783  EXPECT_EQ(1u, abdu(MaxU1, MinU1).getZExtValue());2784  EXPECT_EQ(1u, abdu(MinU1, MaxU1).getZExtValue());2785 2786  APInt MaxU4(4, 15, false);2787  APInt MinU4(4, 0, false);2788  EXPECT_EQ(15u, abdu(MaxU4, MinU4).getZExtValue());2789  EXPECT_EQ(15u, abdu(MinU4, MaxU4).getZExtValue());2790 2791  APInt MaxS8(8, 127, true);2792  APInt MinS8(8, -128, true);2793  EXPECT_EQ(1u, abdu(MaxS8, MinS8).getZExtValue());2794  EXPECT_EQ(1u, abdu(MinS8, MaxS8).getZExtValue());2795 2796  APInt MaxU16(16, 65535, false);2797  APInt MinU16(16, 0, false);2798  EXPECT_EQ(65535u, abdu(MaxU16, MinU16).getZExtValue());2799  EXPECT_EQ(65535u, abdu(MinU16, MaxU16).getZExtValue());2800 2801  APInt MaxS16(16, 32767, true);2802  APInt MinS16(16, -32768, true);2803  APInt ZeroS16(16, 0, true);2804  EXPECT_EQ(1u, abdu(MaxS16, MinS16).getZExtValue());2805  EXPECT_EQ(1u, abdu(MinS16, MaxS16).getZExtValue());2806  EXPECT_EQ(32768u, abdu(ZeroS16, MinS16));2807  EXPECT_EQ(32768u, abdu(MinS16, ZeroS16));2808  EXPECT_EQ(32767u, abdu(ZeroS16, MaxS16));2809  EXPECT_EQ(32767u, abdu(MaxS16, ZeroS16));2810}2811 2812TEST(APIntTest, GCD) {2813  using APIntOps::GreatestCommonDivisor;2814 2815  for (unsigned Bits : {1, 2, 32, 63, 64, 65}) {2816    // Test some corner cases near zero.2817    APInt Zero(Bits, 0), One(Bits, 1);2818    EXPECT_EQ(GreatestCommonDivisor(Zero, Zero), Zero);2819    EXPECT_EQ(GreatestCommonDivisor(Zero, One), One);2820    EXPECT_EQ(GreatestCommonDivisor(One, Zero), One);2821    EXPECT_EQ(GreatestCommonDivisor(One, One), One);2822 2823    if (Bits > 1) {2824      APInt Two(Bits, 2);2825      EXPECT_EQ(GreatestCommonDivisor(Zero, Two), Two);2826      EXPECT_EQ(GreatestCommonDivisor(One, Two), One);2827      EXPECT_EQ(GreatestCommonDivisor(Two, Two), Two);2828 2829      // Test some corner cases near the highest representable value.2830      APInt Max(Bits, 0);2831      Max.setAllBits();2832      EXPECT_EQ(GreatestCommonDivisor(Zero, Max), Max);2833      EXPECT_EQ(GreatestCommonDivisor(One, Max), One);2834      EXPECT_EQ(GreatestCommonDivisor(Two, Max), One);2835      EXPECT_EQ(GreatestCommonDivisor(Max, Max), Max);2836 2837      APInt MaxOver2 = Max.udiv(Two);2838      EXPECT_EQ(GreatestCommonDivisor(MaxOver2, Max), One);2839      // Max - 1 == Max / 2 * 2, because Max is odd.2840      EXPECT_EQ(GreatestCommonDivisor(MaxOver2, Max - 1), MaxOver2);2841    }2842  }2843 2844  // Compute the 20th Mersenne prime.2845  const unsigned BitWidth = 4450;2846  APInt HugePrime = APInt::getLowBitsSet(BitWidth, 4423);2847 2848  // 9931 and 123456 are coprime.2849  APInt A = HugePrime * APInt(BitWidth, 9931);2850  APInt B = HugePrime * APInt(BitWidth, 123456);2851  APInt C = GreatestCommonDivisor(A, B);2852  EXPECT_EQ(C, HugePrime);2853}2854 2855TEST(APIntTest, LogicalRightShift) {2856  APInt i256(APInt::getHighBitsSet(256, 2));2857 2858  i256.lshrInPlace(1);2859  EXPECT_EQ(1U, i256.countl_zero());2860  EXPECT_EQ(253U, i256.countr_zero());2861  EXPECT_EQ(2U, i256.popcount());2862 2863  i256.lshrInPlace(62);2864  EXPECT_EQ(63U, i256.countl_zero());2865  EXPECT_EQ(191U, i256.countr_zero());2866  EXPECT_EQ(2U, i256.popcount());2867 2868  i256.lshrInPlace(65);2869  EXPECT_EQ(128U, i256.countl_zero());2870  EXPECT_EQ(126U, i256.countr_zero());2871  EXPECT_EQ(2U, i256.popcount());2872 2873  i256.lshrInPlace(64);2874  EXPECT_EQ(192U, i256.countl_zero());2875  EXPECT_EQ(62U, i256.countr_zero());2876  EXPECT_EQ(2U, i256.popcount());2877 2878  i256.lshrInPlace(63);2879  EXPECT_EQ(255U, i256.countl_zero());2880  EXPECT_EQ(0U, i256.countr_zero());2881  EXPECT_EQ(1U, i256.popcount());2882 2883  // Ensure we handle large shifts of multi-word.2884  const APInt neg_one(128, static_cast<uint64_t>(-1), true);2885  EXPECT_EQ(0, neg_one.lshr(128));2886}2887 2888TEST(APIntTest, ArithmeticRightShift) {2889  APInt i72(APInt::getHighBitsSet(72, 1));2890  i72.ashrInPlace(46);2891  EXPECT_EQ(47U, i72.countl_one());2892  EXPECT_EQ(25U, i72.countr_zero());2893  EXPECT_EQ(47U, i72.popcount());2894 2895  i72 = APInt::getHighBitsSet(72, 1);2896  i72.ashrInPlace(64);2897  EXPECT_EQ(65U, i72.countl_one());2898  EXPECT_EQ(7U, i72.countr_zero());2899  EXPECT_EQ(65U, i72.popcount());2900 2901  APInt i128(APInt::getHighBitsSet(128, 1));2902  i128.ashrInPlace(64);2903  EXPECT_EQ(65U, i128.countl_one());2904  EXPECT_EQ(63U, i128.countr_zero());2905  EXPECT_EQ(65U, i128.popcount());2906 2907  // Ensure we handle large shifts of multi-word.2908  const APInt signmin32(APInt::getSignedMinValue(32));2909  EXPECT_TRUE(signmin32.ashr(32).isAllOnes());2910 2911  // Ensure we handle large shifts of multi-word.2912  const APInt umax32(APInt::getSignedMaxValue(32));2913  EXPECT_EQ(0, umax32.ashr(32));2914 2915  // Ensure we handle large shifts of multi-word.2916  const APInt signmin128(APInt::getSignedMinValue(128));2917  EXPECT_TRUE(signmin128.ashr(128).isAllOnes());2918 2919  // Ensure we handle large shifts of multi-word.2920  const APInt umax128(APInt::getSignedMaxValue(128));2921  EXPECT_EQ(0, umax128.ashr(128));2922}2923 2924TEST(APIntTest, LeftShift) {2925  APInt i256(APInt::getLowBitsSet(256, 2));2926 2927  i256 <<= 1;2928  EXPECT_EQ(253U, i256.countl_zero());2929  EXPECT_EQ(1U, i256.countr_zero());2930  EXPECT_EQ(2U, i256.popcount());2931 2932  i256 <<= 62;2933  EXPECT_EQ(191U, i256.countl_zero());2934  EXPECT_EQ(63U, i256.countr_zero());2935  EXPECT_EQ(2U, i256.popcount());2936 2937  i256 <<= 65;2938  EXPECT_EQ(126U, i256.countl_zero());2939  EXPECT_EQ(128U, i256.countr_zero());2940  EXPECT_EQ(2U, i256.popcount());2941 2942  i256 <<= 64;2943  EXPECT_EQ(62U, i256.countl_zero());2944  EXPECT_EQ(192U, i256.countr_zero());2945  EXPECT_EQ(2U, i256.popcount());2946 2947  i256 <<= 63;2948  EXPECT_EQ(0U, i256.countl_zero());2949  EXPECT_EQ(255U, i256.countr_zero());2950  EXPECT_EQ(1U, i256.popcount());2951 2952  // Ensure we handle large shifts of multi-word.2953  const APInt neg_one(128, static_cast<uint64_t>(-1), true);2954  EXPECT_EQ(0, neg_one.shl(128));2955}2956 2957TEST(APIntTest, isSubsetOf) {2958  APInt i32_1(32, 1);2959  APInt i32_2(32, 2);2960  APInt i32_3(32, 3);2961  EXPECT_FALSE(i32_3.isSubsetOf(i32_1));2962  EXPECT_TRUE(i32_1.isSubsetOf(i32_3));2963  EXPECT_FALSE(i32_2.isSubsetOf(i32_1));2964  EXPECT_FALSE(i32_1.isSubsetOf(i32_2));2965  EXPECT_TRUE(i32_3.isSubsetOf(i32_3));2966 2967  APInt i128_1(128, 1);2968  APInt i128_2(128, 2);2969  APInt i128_3(128, 3);2970  EXPECT_FALSE(i128_3.isSubsetOf(i128_1));2971  EXPECT_TRUE(i128_1.isSubsetOf(i128_3));2972  EXPECT_FALSE(i128_2.isSubsetOf(i128_1));2973  EXPECT_FALSE(i128_1.isSubsetOf(i128_2));2974  EXPECT_TRUE(i128_3.isSubsetOf(i128_3));2975 2976  i128_1 <<= 64;2977  i128_2 <<= 64;2978  i128_3 <<= 64;2979  EXPECT_FALSE(i128_3.isSubsetOf(i128_1));2980  EXPECT_TRUE(i128_1.isSubsetOf(i128_3));2981  EXPECT_FALSE(i128_2.isSubsetOf(i128_1));2982  EXPECT_FALSE(i128_1.isSubsetOf(i128_2));2983  EXPECT_TRUE(i128_3.isSubsetOf(i128_3));2984}2985 2986TEST(APIntTest, sext) {2987  EXPECT_EQ(0, APInt(1, 0).sext(64));2988  EXPECT_EQ(~uint64_t(0), APInt(1, 1).sext(64));2989 2990  APInt i32_max(APInt::getSignedMaxValue(32).sext(63));2991  EXPECT_EQ(i32_max, i32_max.sext(63));2992  EXPECT_EQ(32U, i32_max.countl_zero());2993  EXPECT_EQ(0U, i32_max.countr_zero());2994  EXPECT_EQ(31U, i32_max.popcount());2995 2996  APInt i32_min(APInt::getSignedMinValue(32).sext(63));2997  EXPECT_EQ(i32_min, i32_min.sext(63));2998  EXPECT_EQ(32U, i32_min.countl_one());2999  EXPECT_EQ(31U, i32_min.countr_zero());3000  EXPECT_EQ(32U, i32_min.popcount());3001 3002  APInt i32_neg1(APInt(32, ~uint32_t(0)).sext(63));3003  EXPECT_EQ(i32_neg1, i32_neg1.sext(63));3004  EXPECT_EQ(63U, i32_neg1.countl_one());3005  EXPECT_EQ(0U, i32_neg1.countr_zero());3006  EXPECT_EQ(63U, i32_neg1.popcount());3007 3008  EXPECT_EQ(APInt(32u, 0), APInt(0u, 0).sext(32));3009  EXPECT_EQ(APInt(64u, 0), APInt(0u, 0).sext(64));3010}3011 3012TEST(APIntTest, trunc) {3013  APInt val(32, 0xFFFFFFFF);3014  EXPECT_EQ(0xFFFF, val.trunc(16));3015  EXPECT_EQ(0xFFFFFFFF, val.trunc(32));3016}3017 3018TEST(APIntTest, concat) {3019  APInt Int1(4, 0x1ULL);3020  APInt Int3(4, 0x3ULL);3021 3022  EXPECT_EQ(0x31, Int3.concat(Int1));3023  EXPECT_EQ(APInt(12, 0x313), Int3.concat(Int1).concat(Int3));3024  EXPECT_EQ(APInt(16, 0x3313), Int3.concat(Int3).concat(Int1).concat(Int3));3025 3026  APInt I64(64, 0x3ULL);3027  EXPECT_EQ(I64, I64.concat(I64).lshr(64).trunc(64));3028 3029  APInt I65(65, 0x3ULL);3030  APInt I0 = APInt::getZeroWidth();3031  EXPECT_EQ(I65, I65.concat(I0));3032  EXPECT_EQ(I65, I0.concat(I65));3033}3034 3035TEST(APIntTest, multiply) {3036  APInt i64(64, 1234);3037 3038  EXPECT_EQ(7006652, i64 * 5678);3039  EXPECT_EQ(7006652, 5678 * i64);3040 3041  APInt i128 = APInt::getOneBitSet(128, 64);3042  APInt i128_1234(128, 1234);3043  i128_1234 <<= 64;3044  EXPECT_EQ(i128_1234, i128 * 1234);3045  EXPECT_EQ(i128_1234, 1234 * i128);3046 3047  APInt i96 = APInt::getOneBitSet(96, 64);3048  i96 *= ~0ULL;3049  EXPECT_EQ(32U, i96.countl_one());3050  EXPECT_EQ(32U, i96.popcount());3051  EXPECT_EQ(64U, i96.countr_zero());3052}3053 3054TEST(APIntOpsTest, Mulh) {3055 3056  // Unsigned3057 3058  // 32 bits3059  APInt i32a(32, 0x0001'E235);3060  APInt i32b(32, 0xF623'55AD);3061  EXPECT_EQ(0x0001'CFA1, APIntOps::mulhu(i32a, i32b));3062 3063  // 64 bits3064  APInt i64a(64, 0x1234'5678'90AB'CDEF);3065  APInt i64b(64, 0xFEDC'BA09'8765'4321);3066  EXPECT_EQ(0x121F'A000'A372'3A57, APIntOps::mulhu(i64a, i64b));3067 3068  // 128 bits3069  APInt i128a(128, "1234567890ABCDEF1234567890ABCDEF", 16);3070  APInt i128b(128, "FEDCBA0987654321FEDCBA0987654321", 16);3071  APInt i128Res = APIntOps::mulhu(i128a, i128b);3072  EXPECT_EQ(APInt(128, "121FA000A3723A57E68984312C3A8D7E", 16), i128Res);3073 3074  // Signed3075 3076  // 32 bits3077  APInt i32c(32, 0x1234'5678); // +ve3078  APInt i32d(32, 0x10AB'CDEF); // +ve3079  APInt i32e(32, 0xFEDC'BA09); // -ve3080 3081  EXPECT_EQ(0x012F'7D02, APIntOps::mulhs(i32c, i32d));3082  EXPECT_EQ(0xFFEB'4988, APIntOps::mulhs(i32c, i32e));3083  EXPECT_EQ(0x0001'4B68, APIntOps::mulhs(i32e, i32e));3084 3085  // 64 bits3086  APInt i64c(64, 0x1234'5678'90AB'CDEF); // +ve3087  APInt i64d(64, 0x1234'5678'90FE'DCBA); // +ve3088  APInt i64e(64, 0xFEDC'BA09'8765'4321); // -ve3089 3090  EXPECT_EQ(0x014B'66DC'328E'10C1, APIntOps::mulhs(i64c, i64d));3091  EXPECT_EQ(0xFFEB'4988'12C6'6C68, APIntOps::mulhs(i64c, i64e));3092  EXPECT_EQ(0x0001'4B68'2174'FA18, APIntOps::mulhs(i64e, i64e));3093 3094  // 128 bits3095  APInt i128c(128, "1234567890ABCDEF1234567890ABCDEF", 16); // +ve3096  APInt i128d(128, "1234567890FEDCBA1234567890FEDCBA", 16); // +ve3097  APInt i128e(128, "FEDCBA0987654321FEDCBA0987654321", 16); // -ve3098 3099  i128Res = APIntOps::mulhs(i128c, i128d);3100  EXPECT_EQ(APInt(128, "14B66DC328E10C1FE303DF9EA0B2529", 16), i128Res);3101 3102  i128Res = APIntOps::mulhs(i128c, i128e);3103  EXPECT_EQ(APInt(128, "FFEB498812C66C68D4552DB89B8EBF8F", 16), i128Res);3104}3105 3106TEST(APIntOpsTest, muli) {3107  APInt u32a(32, 0x0001'E235);3108  APInt u32b(32, 0xF623'55AD);3109  EXPECT_EQ(0x0001'CFA1'7CA0'76D1, APIntOps::muluExtended(u32a, u32b));3110 3111  APInt u64a(64, 0x1234'5678'90AB'CDEF);3112  APInt u64b(64, 0xFEDC'BA09'8765'4321);3113  EXPECT_EQ(APInt(128, "121FA000A3723A57C24A442FE55618CF", 16),3114            APIntOps::muluExtended(u64a, u64b));3115 3116  APInt u128a(128, "1234567890ABCDEF1234567890ABCDEF", 16);3117  APInt u128b(128, "FEDCBA0987654321FEDCBA0987654321", 16);3118  EXPECT_EQ(3119      APInt(256,3120            "121FA000A3723A57E68984312C3A8D7E96B428606E1E6BF5C24A442FE55618CF",3121            16),3122      APIntOps::muluExtended(u128a, u128b));3123 3124  APInt s32a(32, 0x1234'5678);3125  APInt s32b(32, 0x10AB'CDEF);3126  APInt s32c(32, 0xFEDC'BA09);3127  EXPECT_EQ(0x012F'7D02'2A42'D208, APIntOps::mulsExtended(s32a, s32b));3128  EXPECT_EQ(0xFFEB'4988'09CA'3A38, APIntOps::mulsExtended(s32a, s32c));3129 3130  APInt s64a(64, 0x1234'5678'90AB'CDEF);3131  APInt s64b(64, 0x1234'5678'90FE'DCBA);3132  APInt s64c(64, 0xFEDC'BA09'8765'4321);3133  EXPECT_EQ(APInt(128, "014B66DC328E10C1FB99704184EF03A6", 16),3134            APIntOps::mulsExtended(s64a, s64b));3135  EXPECT_EQ(APInt(128, "FFEB498812C66C68C24A442FE55618CF", 16),3136            APIntOps::mulsExtended(s64a, s64c));3137 3138  APInt s128a(128, "1234567890ABCDEF1234567890ABCDEF", 16);3139  APInt s128b(128, "1234567890FEDCBA1234567890FEDCBA", 16);3140  APInt s128c(128, "FEDCBA0987654321FEDCBA0987654321", 16);3141  EXPECT_EQ(3142      APInt(256,3143            "014B66DC328E10C1FE303DF9EA0B2529F87E475F3C6C180DFB99704184EF03A6",3144            16),3145      APIntOps::mulsExtended(s128a, s128b));3146  EXPECT_EQ(3147      APInt(256,3148            "FFEB498812C66C68D4552DB89B8EBF8F96B428606E1E6BF5C24A442FE55618CF",3149            16),3150      APIntOps::mulsExtended(s128a, s128c));3151}3152 3153TEST(APIntTest, RoundingUDiv) {3154  for (uint64_t Ai = 1; Ai <= 255; Ai++) {3155    APInt A(8, Ai);3156    APInt Zero(8, 0);3157    EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::UP));3158    EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::DOWN));3159    EXPECT_EQ(0, APIntOps::RoundingUDiv(Zero, A, APInt::Rounding::TOWARD_ZERO));3160 3161    for (uint64_t Bi = 1; Bi <= 255; Bi++) {3162      APInt B(8, Bi);3163      {3164        APInt Quo = APIntOps::RoundingUDiv(A, B, APInt::Rounding::UP);3165        auto Prod = Quo.zext(16) * B.zext(16);3166        EXPECT_TRUE(Prod.uge(Ai));3167        if (Prod.ugt(Ai)) {3168          EXPECT_TRUE(((Quo - 1).zext(16) * B.zext(16)).ult(Ai));3169        }3170      }3171      {3172        APInt Quo = A.udiv(B);3173        EXPECT_EQ(Quo, APIntOps::RoundingUDiv(A, B, APInt::Rounding::TOWARD_ZERO));3174        EXPECT_EQ(Quo, APIntOps::RoundingUDiv(A, B, APInt::Rounding::DOWN));3175      }3176    }3177  }3178}3179 3180TEST(APIntTest, RoundingSDiv) {3181  for (int64_t Ai = -128; Ai <= 127; Ai++) {3182    APInt A(8, Ai, true);3183 3184    if (Ai != 0) {3185      APInt Zero(8, 0);3186      EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::UP));3187      EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::DOWN));3188      EXPECT_EQ(0, APIntOps::RoundingSDiv(Zero, A, APInt::Rounding::TOWARD_ZERO));3189    }3190 3191    for (int64_t Bi = -128; Bi <= 127; Bi++) {3192      if (Bi == 0)3193        continue;3194 3195      APInt B(8, Bi, true);3196      APInt QuoTowardZero = A.sdiv(B);3197      {3198        APInt Quo = APIntOps::RoundingSDiv(A, B, APInt::Rounding::UP);3199        if (A.srem(B).isZero()) {3200          EXPECT_EQ(QuoTowardZero, Quo);3201        } else if (A.isNegative() !=3202                   B.isNegative()) { // if the math quotient is negative.3203          EXPECT_EQ(QuoTowardZero, Quo);3204        } else {3205          EXPECT_EQ(QuoTowardZero + 1, Quo);3206        }3207      }3208      {3209        APInt Quo = APIntOps::RoundingSDiv(A, B, APInt::Rounding::DOWN);3210        if (A.srem(B).isZero()) {3211          EXPECT_EQ(QuoTowardZero, Quo);3212        } else if (A.isNegative() !=3213                   B.isNegative()) { // if the math quotient is negative.3214          EXPECT_EQ(QuoTowardZero - 1, Quo);3215        } else {3216          EXPECT_EQ(QuoTowardZero, Quo);3217        }3218      }3219      EXPECT_EQ(QuoTowardZero,3220                APIntOps::RoundingSDiv(A, B, APInt::Rounding::TOWARD_ZERO));3221    }3222  }3223}3224 3225TEST(APIntTest, Average) {3226  APInt A0(32, 0);3227  APInt A2(32, 2);3228  APInt A100(32, 100);3229  APInt A101(32, 101);3230  APInt A200(32, 200, false);3231  APInt ApUMax = APInt::getMaxValue(32);3232 3233  EXPECT_EQ(APInt(32, 150), APIntOps::avgFloorU(A100, A200));3234  EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A200, A2, APInt::Rounding::DOWN),3235            APIntOps::avgFloorU(A100, A200));3236  EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A200, A2, APInt::Rounding::UP),3237            APIntOps::avgCeilU(A100, A200));3238  EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A101, A2, APInt::Rounding::DOWN),3239            APIntOps::avgFloorU(A100, A101));3240  EXPECT_EQ(APIntOps::RoundingUDiv(A100 + A101, A2, APInt::Rounding::UP),3241            APIntOps::avgCeilU(A100, A101));3242  EXPECT_EQ(A0, APIntOps::avgFloorU(A0, A0));3243  EXPECT_EQ(A0, APIntOps::avgCeilU(A0, A0));3244  EXPECT_EQ(ApUMax, APIntOps::avgFloorU(ApUMax, ApUMax));3245  EXPECT_EQ(ApUMax, APIntOps::avgCeilU(ApUMax, ApUMax));3246  EXPECT_EQ(APIntOps::RoundingUDiv(ApUMax, A2, APInt::Rounding::DOWN),3247            APIntOps::avgFloorU(A0, ApUMax));3248  EXPECT_EQ(APIntOps::RoundingUDiv(ApUMax, A2, APInt::Rounding::UP),3249            APIntOps::avgCeilU(A0, ApUMax));3250 3251  APInt Ap100(32, +100);3252  APInt Ap101(32, +101);3253  APInt Ap200(32, +200);3254  APInt Am1(32, -1, true);3255  APInt Am100(32, -100, true);3256  APInt Am101(32, -101, true);3257  APInt Am200(32, -200, true);3258  APInt AmSMin = APInt::getSignedMinValue(32);3259  APInt ApSMax = APInt::getSignedMaxValue(32);3260 3261  EXPECT_EQ(APInt(32, +150), APIntOps::avgFloorS(Ap100, Ap200));3262  EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap200, A2, APInt::Rounding::DOWN),3263            APIntOps::avgFloorS(Ap100, Ap200));3264  EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap200, A2, APInt::Rounding::UP),3265            APIntOps::avgCeilS(Ap100, Ap200));3266 3267  EXPECT_EQ(APInt(32, -150, true), APIntOps::avgFloorS(Am100, Am200));3268  EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am200, A2, APInt::Rounding::DOWN),3269            APIntOps::avgFloorS(Am100, Am200));3270  EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am200, A2, APInt::Rounding::UP),3271            APIntOps::avgCeilS(Am100, Am200));3272 3273  EXPECT_EQ(APInt(32, +100), APIntOps::avgFloorS(Ap100, Ap101));3274  EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap101, A2, APInt::Rounding::DOWN),3275            APIntOps::avgFloorS(Ap100, Ap101));3276  EXPECT_EQ(APInt(32, +101), APIntOps::avgCeilS(Ap100, Ap101));3277  EXPECT_EQ(APIntOps::RoundingSDiv(Ap100 + Ap101, A2, APInt::Rounding::UP),3278            APIntOps::avgCeilS(Ap100, Ap101));3279 3280  EXPECT_EQ(APInt(32, -101, true), APIntOps::avgFloorS(Am100, Am101));3281  EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am101, A2, APInt::Rounding::DOWN),3282            APIntOps::avgFloorS(Am100, Am101));3283  EXPECT_EQ(APInt(32, -100, true), APIntOps::avgCeilS(Am100, Am101));3284  EXPECT_EQ(APIntOps::RoundingSDiv(Am100 + Am101, A2, APInt::Rounding::UP),3285            APIntOps::avgCeilS(Am100, Am101));3286 3287  EXPECT_EQ(AmSMin, APIntOps::avgFloorS(AmSMin, AmSMin));3288  EXPECT_EQ(AmSMin, APIntOps::avgCeilS(AmSMin, AmSMin));3289 3290  EXPECT_EQ(APIntOps::RoundingSDiv(AmSMin, A2, APInt::Rounding::DOWN),3291            APIntOps::avgFloorS(A0, AmSMin));3292  EXPECT_EQ(APIntOps::RoundingSDiv(AmSMin, A2, APInt::Rounding::UP),3293            APIntOps::avgCeilS(A0, AmSMin));3294 3295  EXPECT_EQ(A0, APIntOps::avgFloorS(A0, A0));3296  EXPECT_EQ(A0, APIntOps::avgCeilS(A0, A0));3297 3298  EXPECT_EQ(Am1, APIntOps::avgFloorS(AmSMin, ApSMax));3299  EXPECT_EQ(A0, APIntOps::avgCeilS(AmSMin, ApSMax));3300 3301  EXPECT_EQ(APIntOps::RoundingSDiv(ApSMax, A2, APInt::Rounding::DOWN),3302            APIntOps::avgFloorS(A0, ApSMax));3303  EXPECT_EQ(APIntOps::RoundingSDiv(ApSMax, A2, APInt::Rounding::UP),3304            APIntOps::avgCeilS(A0, ApSMax));3305 3306  EXPECT_EQ(ApSMax, APIntOps::avgFloorS(ApSMax, ApSMax));3307  EXPECT_EQ(ApSMax, APIntOps::avgCeilS(ApSMax, ApSMax));3308}3309 3310TEST(APIntTest, umul_ov) {3311  const std::pair<uint64_t, uint64_t> Overflows[] = {3312      {0x8000000000000000, 2},3313      {0x5555555555555556, 3},3314      {4294967296, 4294967296},3315      {4294967295, 4294967298},3316  };3317  const std::pair<uint64_t, uint64_t> NonOverflows[] = {3318      {0x7fffffffffffffff, 2},3319      {0x5555555555555555, 3},3320      {4294967295, 4294967297},3321  };3322 3323  bool Overflow;3324  for (auto &X : Overflows) {3325    APInt A(64, X.first);3326    APInt B(64, X.second);3327    (void)A.umul_ov(B, Overflow);3328    EXPECT_TRUE(Overflow);3329  }3330  for (auto &X : NonOverflows) {3331    APInt A(64, X.first);3332    APInt B(64, X.second);3333    (void)A.umul_ov(B, Overflow);3334    EXPECT_FALSE(Overflow);3335  }3336 3337  for (unsigned Bits = 1; Bits <= 5; ++Bits)3338    for (unsigned A = 0; A != 1u << Bits; ++A)3339      for (unsigned B = 0; B != 1u << Bits; ++B) {3340        APInt N1 = APInt(Bits, A), N2 = APInt(Bits, B);3341        APInt Narrow = N1.umul_ov(N2, Overflow);3342        APInt Wide = N1.zext(2 * Bits) * N2.zext(2 * Bits);3343        EXPECT_EQ(Wide.trunc(Bits), Narrow);3344        EXPECT_EQ(Narrow.zext(2 * Bits) != Wide, Overflow);3345      }3346}3347 3348TEST(APIntTest, smul_ov) {3349  for (unsigned Bits = 1; Bits <= 5; ++Bits)3350    for (unsigned A = 0; A != 1u << Bits; ++A)3351      for (unsigned B = 0; B != 1u << Bits; ++B) {3352        bool Overflow;3353        APInt N1 = APInt(Bits, A), N2 = APInt(Bits, B);3354        APInt Narrow = N1.smul_ov(N2, Overflow);3355        APInt Wide = N1.sext(2 * Bits) * N2.sext(2 * Bits);3356        EXPECT_EQ(Wide.trunc(Bits), Narrow);3357        EXPECT_EQ(Narrow.sext(2 * Bits) != Wide, Overflow);3358      }3359}3360 3361TEST(APIntTest, sfloordiv_ov) {3362  // int16 test overflow3363  {3364    using IntTy = int16_t;3365    APInt divisor(8 * sizeof(IntTy), std::numeric_limits<IntTy>::lowest(),3366                  true);3367    APInt dividend(8 * sizeof(IntTy), IntTy(-1), true);3368    bool Overflow = false;3369    (void)divisor.sfloordiv_ov(dividend, Overflow);3370    EXPECT_TRUE(Overflow);3371  }3372  // int32 test overflow3373  {3374    using IntTy = int32_t;3375    APInt divisor(8 * sizeof(IntTy), std::numeric_limits<IntTy>::lowest(),3376                  true);3377    APInt dividend(8 * sizeof(IntTy), IntTy(-1), true);3378    bool Overflow = false;3379    (void)divisor.sfloordiv_ov(dividend, Overflow);3380    EXPECT_TRUE(Overflow);3381  }3382  // int64 test overflow3383  {3384    using IntTy = int64_t;3385    APInt divisor(8 * sizeof(IntTy), std::numeric_limits<IntTy>::lowest(),3386                  true);3387    APInt dividend(8 * sizeof(IntTy), IntTy(-1), true);3388    bool Overflow = false;3389    (void)divisor.sfloordiv_ov(dividend, Overflow);3390    EXPECT_TRUE(Overflow);3391  }3392  // test all of int83393  {3394    bool Overflow = false;3395    for (int i = -128; i < 128; ++i) {3396      for (int j = -128; j < 128; ++j) {3397        if (j == 0)3398          continue;3399 3400        int8_t a = static_cast<int8_t>(i);3401        int8_t b = static_cast<int8_t>(j);3402 3403        APInt divisor(8, a, true);3404        APInt dividend(8, b, true);3405        APInt quotient = divisor.sfloordiv_ov(dividend, Overflow);3406 3407        if (i == -128 && j == -1) {3408          EXPECT_TRUE(Overflow);3409          continue;3410        }3411 3412        if (((i >= 0 && j > 0) || (i <= 0 && j < 0)) ||3413            (i % j == 0)) // if quotient >= 0 and remain == 0 floordiv3414                          // equivalent to div3415          EXPECT_EQ(quotient.getSExtValue(), a / b);3416        else3417          EXPECT_EQ(quotient.getSExtValue(), a / b - 1);3418        EXPECT_FALSE(Overflow);3419      }3420    }3421  }3422}3423 3424TEST(APIntTest, SolveQuadraticEquationWrap) {3425  // Verify that "Solution" is the first non-negative integer that solves3426  // Ax^2 + Bx + C = "0 or overflow", i.e. that it is a correct solution3427  // as calculated by SolveQuadraticEquationWrap.3428  auto Validate = [] (int A, int B, int C, unsigned Width, int Solution) {3429    int Mask = (1 << Width) - 1;3430 3431    // Solution should be non-negative.3432    EXPECT_GE(Solution, 0);3433 3434    auto OverflowBits = [] (int64_t V, unsigned W) {3435      return V & -(1 << W);3436    };3437 3438    int64_t Over0 = OverflowBits(C, Width);3439 3440    auto IsZeroOrOverflow = [&] (int X) {3441      int64_t ValueAtX = A*X*X + B*X + C;3442      int64_t OverX = OverflowBits(ValueAtX, Width);3443      return (ValueAtX & Mask) == 0 || OverX != Over0;3444    };3445 3446    auto EquationToString = [&] (const char *X_str) {3447      return (Twine(A) + Twine(X_str) + Twine("^2 + ") + Twine(B) +3448              Twine(X_str) + Twine(" + ") + Twine(C) + Twine(", bitwidth: ") +3449              Twine(Width)).str();3450    };3451 3452    auto IsSolution = [&] (const char *X_str, int X) {3453      if (IsZeroOrOverflow(X))3454        return ::testing::AssertionSuccess()3455                  << X << " is a solution of " << EquationToString(X_str);3456      return ::testing::AssertionFailure()3457                << X << " is not an expected solution of "3458                << EquationToString(X_str);3459    };3460 3461    auto IsNotSolution = [&] (const char *X_str, int X) {3462      if (!IsZeroOrOverflow(X))3463        return ::testing::AssertionSuccess()3464                  << X << " is not a solution of " << EquationToString(X_str);3465      return ::testing::AssertionFailure()3466                << X << " is an unexpected solution of "3467                << EquationToString(X_str);3468    };3469 3470    // This is the important part: make sure that there is no solution that3471    // is less than the calculated one.3472    if (Solution > 0) {3473      for (int X = 1; X < Solution-1; ++X)3474        EXPECT_PRED_FORMAT1(IsNotSolution, X);3475    }3476 3477    // Verify that the calculated solution is indeed a solution.3478    EXPECT_PRED_FORMAT1(IsSolution, Solution);3479  };3480 3481  // Generate all possible quadratic equations with Width-bit wide integer3482  // coefficients, get the solution from SolveQuadraticEquationWrap, and3483  // verify that the solution is correct.3484  auto Iterate = [&] (unsigned Width) {3485    assert(1 < Width && Width < 32);3486    int Low = -(1 << (Width-1));3487    int High = (1 << (Width-1));3488 3489    for (int A = Low; A != High; ++A) {3490      if (A == 0)3491        continue;3492      for (int B = Low; B != High; ++B) {3493        for (int C = Low; C != High; ++C) {3494          std::optional<APInt> S = APIntOps::SolveQuadraticEquationWrap(3495              APInt(Width, A, true), APInt(Width, B, true),3496              APInt(Width, C, true), Width);3497          if (S)3498            Validate(A, B, C, Width, S->getSExtValue());3499        }3500      }3501    }3502  };3503 3504  // Test all widths in [2..6].3505  for (unsigned i = 2; i <= 6; ++i)3506    Iterate(i);3507}3508 3509TEST(APIntTest, MultiplicativeInverseExaustive) {3510  for (unsigned BitWidth = 1; BitWidth <= 8; ++BitWidth) {3511    for (unsigned Value = 1; Value < (1u << BitWidth); Value += 2) {3512      // Multiplicative inverse exists for all odd numbers.3513      APInt V = APInt(BitWidth, Value);3514      EXPECT_EQ(V * V.multiplicativeInverse(), 1);3515    }3516  }3517}3518 3519TEST(APIntTest, GetMostSignificantDifferentBit) {3520  EXPECT_EQ(APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 0)),3521            std::nullopt);3522  EXPECT_EQ(3523      APIntOps::GetMostSignificantDifferentBit(APInt(8, 42), APInt(8, 42)),3524      std::nullopt);3525  EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 1)),3526            0u);3527  EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 2)),3528            1u);3529  EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 0), APInt(8, 3)),3530            1u);3531  EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 0)),3532            0u);3533  EXPECT_EQ(APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 1)),3534            std::nullopt);3535  EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 2)),3536            1u);3537  EXPECT_EQ(*APIntOps::GetMostSignificantDifferentBit(APInt(8, 1), APInt(8, 3)),3538            1u);3539  EXPECT_EQ(3540      *APIntOps::GetMostSignificantDifferentBit(APInt(8, 42), APInt(8, 112)),3541      6u);3542}3543 3544TEST(APIntTest, GetMostSignificantDifferentBitExaustive) {3545  auto GetHighestDifferentBitBruteforce =3546      [](const APInt &V0, const APInt &V1) -> std::optional<unsigned> {3547    assert(V0.getBitWidth() == V1.getBitWidth() && "Must have same bitwidth");3548    if (V0 == V1)3549      return std::nullopt; // Bitwise identical.3550    // There is a mismatch. Let's find the most significant different bit.3551    for (int Bit = V0.getBitWidth() - 1; Bit >= 0; --Bit) {3552      if (V0[Bit] == V1[Bit])3553        continue;3554      return Bit;3555    }3556    llvm_unreachable("Must have found bit mismatch.");3557  };3558 3559  for (unsigned BitWidth = 1; BitWidth <= 8; ++BitWidth) {3560    for (unsigned V0 = 0; V0 < (1u << BitWidth); ++V0) {3561      for (unsigned V1 = 0; V1 < (1u << BitWidth); ++V1) {3562        APInt A = APInt(BitWidth, V0);3563        APInt B = APInt(BitWidth, V1);3564 3565        auto Bit = APIntOps::GetMostSignificantDifferentBit(A, B);3566        EXPECT_EQ(Bit, GetHighestDifferentBitBruteforce(A, B));3567 3568        if (!Bit)3569          EXPECT_EQ(A, B);3570        else {3571          EXPECT_NE(A, B);3572          for (unsigned NumLowBits = 0; NumLowBits <= BitWidth; ++NumLowBits) {3573            APInt Adash = A;3574            Adash.clearLowBits(NumLowBits);3575            APInt Bdash = B;3576            Bdash.clearLowBits(NumLowBits);3577            // Clearing only low bits up to and including *Bit is sufficient3578            // to make values equal.3579            if (NumLowBits >= 1 + *Bit)3580              EXPECT_EQ(Adash, Bdash);3581            else3582              EXPECT_NE(Adash, Bdash);3583          }3584        }3585      }3586    }3587  }3588}3589 3590TEST(APIntTest, SignbitZeroChecks) {3591  EXPECT_TRUE(APInt(8, -1, true).isNegative());3592  EXPECT_FALSE(APInt(8, -1, true).isNonNegative());3593  EXPECT_FALSE(APInt(8, -1, true).isStrictlyPositive());3594  EXPECT_TRUE(APInt(8, -1, true).isNonPositive());3595 3596  EXPECT_FALSE(APInt(8, 0).isNegative());3597  EXPECT_TRUE(APInt(8, 0).isNonNegative());3598  EXPECT_FALSE(APInt(8, 0).isStrictlyPositive());3599  EXPECT_TRUE(APInt(8, 0).isNonPositive());3600 3601  EXPECT_FALSE(APInt(8, 1).isNegative());3602  EXPECT_TRUE(APInt(8, 1).isNonNegative());3603  EXPECT_TRUE(APInt(8, 1).isStrictlyPositive());3604  EXPECT_FALSE(APInt(8, 1).isNonPositive());3605}3606 3607TEST(APIntTest, ZeroWidth) {3608  // Zero width Constructors.3609  auto ZW = APInt::getZeroWidth();3610  EXPECT_EQ(0U, ZW.getBitWidth());3611  EXPECT_EQ(0U, APInt(0, ArrayRef<uint64_t>({0, 1, 2})).getBitWidth());3612  EXPECT_EQ(0U, APInt(0, "0", 10).getBitWidth());3613  EXPECT_EQ(0U, APInt::getAllOnes(0).getBitWidth());3614 3615  // Default constructor is single bit wide.3616  EXPECT_EQ(1U, APInt().getBitWidth());3617 3618  // Copy ctor (move is down below).3619  APInt ZW2(ZW);3620  EXPECT_EQ(0U, ZW2.getBitWidth());3621  // Assignment3622  ZW = ZW2;3623  EXPECT_EQ(0U, ZW.getBitWidth());3624 3625  // Methods like getLowBitsSet work with zero bits.3626  EXPECT_EQ(0U, APInt::getLowBitsSet(0, 0).getBitWidth());3627  EXPECT_EQ(0U, APInt::getSplat(0, ZW).getBitWidth());3628  EXPECT_EQ(0U, APInt(4, 10).extractBits(0, 2).getBitWidth());3629  EXPECT_EQ(0U, APInt(4, 10).extractBitsAsZExtValue(0, 2));3630 3631  // Logical operators.3632  ZW |= ZW2;3633  ZW &= ZW2;3634  ZW ^= ZW2;3635  ZW |= 42; // These ignore high bits of the literal.3636  ZW &= 42;3637  ZW ^= 42;3638  EXPECT_EQ(1, ZW.isIntN(0));3639 3640  // Modulo Arithmetic.  Divide/Rem aren't defined on division by zero, so they3641  // aren't supported.3642  ZW += ZW2;3643  ZW -= ZW2;3644  ZW *= ZW2;3645 3646  // Logical Shifts and rotates, the amount must be <= bitwidth.3647  ZW <<= 0;3648  ZW.lshrInPlace(0);3649  (void)ZW.rotl(0);3650  (void)ZW.rotr(0);3651 3652  // Comparisons.3653  EXPECT_EQ(1, ZW == ZW);3654  EXPECT_EQ(0, ZW != ZW);3655  EXPECT_EQ(0, ZW.ult(ZW));3656 3657  // Mutations.3658  ZW.setBitsWithWrap(0, 0);3659  ZW.setBits(0, 0);3660  ZW.clearAllBits();3661  ZW.flipAllBits();3662 3663  // Leading, trailing, ctpop, etc3664  EXPECT_EQ(0U, ZW.countl_zero());3665  EXPECT_EQ(0U, ZW.countl_one());3666  EXPECT_EQ(0U, ZW.popcount());3667  EXPECT_EQ(0U, ZW.reverseBits().getBitWidth());3668  EXPECT_EQ(0U, ZW.getHiBits(0).getBitWidth());3669  EXPECT_EQ(0U, ZW.getLoBits(0).getBitWidth());3670  EXPECT_EQ(0, ZW.zext(4));3671  EXPECT_EQ(0U, APInt(4, 3).trunc(0).getBitWidth());3672  EXPECT_TRUE(ZW.isAllOnes());3673 3674  // Zero extension.3675  EXPECT_EQ(0U, ZW.getZExtValue());3676 3677  SmallString<42> STR;3678  ZW.toStringUnsigned(STR);3679  EXPECT_EQ("0", STR);3680 3681  // Move ctor (keep at the end of the method since moves are destructive).3682  APInt MZW1(std::move(ZW));3683  EXPECT_EQ(0U, MZW1.getBitWidth());3684  // Move Assignment3685  MZW1 = std::move(ZW2);3686  EXPECT_EQ(0U, MZW1.getBitWidth());3687}3688 3689TEST(APIntTest, ScaleBitMask) {3690  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x00), 8), APInt(8, 0x00));3691  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x01), 8), APInt(8, 0x0F));3692  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x02), 8), APInt(8, 0xF0));3693  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x03), 8), APInt(8, 0xFF));3694 3695  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0x00), 4), APInt(4, 0x00));3696  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xFF), 4), APInt(4, 0x0F));3697  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xE4), 4), APInt(4, 0x0E));3698 3699  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0x00), 8), APInt(8, 0x00));3700 3701  EXPECT_EQ(APIntOps::ScaleBitMask(APInt::getZero(1024), 4096),3702            APInt::getZero(4096));3703  EXPECT_EQ(APIntOps::ScaleBitMask(APInt::getAllOnes(4096), 256),3704            APInt::getAllOnes(256));3705  EXPECT_EQ(APIntOps::ScaleBitMask(APInt::getOneBitSet(4096, 32), 256),3706            APInt::getOneBitSet(256, 2));3707 3708  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x00), 8, true), APInt(8, 0x00));3709  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x01), 8, true), APInt(8, 0x0F));3710  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x02), 8, true), APInt(8, 0xF0));3711  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(2, 0x03), 8, true), APInt(8, 0xFF));3712 3713  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0x00), 4, true), APInt(4, 0x00));3714  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xFF), 4, true), APInt(4, 0x0F));3715  EXPECT_EQ(APIntOps::ScaleBitMask(APInt(8, 0xE4), 4, true), APInt(4, 0x08));3716}3717 3718TEST(APIntTest, DenseMap) {3719  DenseMap<APInt, int> Map;3720  APInt ZeroWidthInt(0, 0, false);3721  Map.insert({ZeroWidthInt, 123});3722  auto It = Map.find(ZeroWidthInt);3723  EXPECT_EQ(It->second, 123);3724}3725 3726TEST(APIntTest, TryExt) {3727  APInt small(32, 42);3728  APInt large(128, {0xffff, 0xffff});3729  ASSERT_TRUE(small.tryZExtValue().has_value());3730  ASSERT_TRUE(small.trySExtValue().has_value());3731  ASSERT_FALSE(large.tryZExtValue().has_value());3732  ASSERT_FALSE(large.trySExtValue().has_value());3733  ASSERT_EQ(small.trySExtValue().value_or(41), 42);3734  ASSERT_EQ(large.trySExtValue().value_or(41), 41);3735 3736  APInt negOne32(32, 0);3737  negOne32.setAllBits();3738  ASSERT_EQ(negOne32.trySExtValue().value_or(42), -1);3739  APInt negOne64(64, 0);3740  negOne64.setAllBits();3741  ASSERT_EQ(negOne64.trySExtValue().value_or(42), -1);3742  APInt negOne128(128, 0);3743  negOne128.setAllBits();3744  ASSERT_EQ(negOne128.trySExtValue().value_or(42), -1);3745  ASSERT_EQ(42, APInt(128, -1).trySExtValue().value_or(42));3746}3747 3748TEST(APIntTest, Fshl) {3749  EXPECT_EQ(3750      APIntOps::fshl(APInt(8, 0), APInt(8, 255), APInt(8, 8)).getZExtValue(),3751      0U);3752  EXPECT_EQ(3753      APIntOps::fshl(APInt(8, 255), APInt(8, 0), APInt(8, 8)).getZExtValue(),3754      255U);3755  EXPECT_EQ(3756      APIntOps::fshl(APInt(8, 255), APInt(8, 0), APInt(8, 15)).getZExtValue(),3757      128U);3758  EXPECT_EQ(3759      APIntOps::fshl(APInt(8, 15), APInt(8, 15), APInt(8, 11)).getZExtValue(),3760      120U);3761  EXPECT_EQ(3762      APIntOps::fshl(APInt(8, 2), APInt(8, 1), APInt(8, 3)).getZExtValue(),3763      16U);3764  EXPECT_EQ(3765      APIntOps::fshl(APInt(8, 2), APInt(8, 1), APInt(8, 1)).getZExtValue(),3766      APIntOps::fshl(APInt(8, 2), APInt(8, 1), APInt(8, 9)).getZExtValue());3767  EXPECT_EQ(3768      APIntOps::fshl(APInt(8, 2), APInt(8, 1), APInt(8, 7)).getZExtValue(),3769      APIntOps::fshl(APInt(8, 2), APInt(8, 1), APInt(8, 15)).getZExtValue());3770  EXPECT_EQ(APIntOps::fshl(APInt(32, 0, /*isSigned*/ true),3771                           APInt(32, 2147483647, /*isSigned*/ true),3772                           APInt(32, 32, /*isSigned*/ true))3773                .getSExtValue(),3774            0);3775  EXPECT_EQ(APIntOps::fshl(APInt(64, 1, /*isSigned*/ true),3776                           APInt(64, 2, /*isSigned*/ true),3777                           APInt(64, 3, /*isSigned*/ true))3778                .getSExtValue(),3779            8);3780  EXPECT_EQ(APIntOps::fshl(APInt(16, -2, /*isSigned*/ true),3781                           APInt(16, -1, /*isSigned*/ true),3782                           APInt(16, 3, /*isSigned*/ true))3783                .getSExtValue(),3784            -9);3785}3786 3787TEST(APIntTest, Fshr) {3788  EXPECT_EQ(3789      APIntOps::fshr(APInt(8, 0), APInt(8, 255), APInt(8, 8)).getZExtValue(),3790      255U);3791  EXPECT_EQ(3792      APIntOps::fshr(APInt(8, 255), APInt(8, 0), APInt(8, 8)).getZExtValue(),3793      0U);3794  EXPECT_EQ(3795      APIntOps::fshr(APInt(8, 255), APInt(8, 0), APInt(8, 15)).getZExtValue(),3796      254U);3797  EXPECT_EQ(3798      APIntOps::fshr(APInt(8, 15), APInt(8, 15), APInt(8, 11)).getZExtValue(),3799      225U);3800  EXPECT_EQ(3801      APIntOps::fshr(APInt(8, 1), APInt(8, 2), APInt(8, 3)).getZExtValue(),3802      32U);3803  EXPECT_EQ(3804      APIntOps::fshr(APInt(8, 1), APInt(8, 2), APInt(8, 1)).getZExtValue(),3805      APIntOps::fshr(APInt(8, 1), APInt(8, 2), APInt(8, 9)).getZExtValue());3806  EXPECT_EQ(3807      APIntOps::fshr(APInt(8, 1), APInt(8, 2), APInt(8, 7)).getZExtValue(),3808      APIntOps::fshr(APInt(8, 1), APInt(8, 2), APInt(8, 15)).getZExtValue());3809  EXPECT_EQ(APIntOps::fshr(APInt(64, 0, /*isSigned*/ true),3810                           APInt(64, 9223372036854775807, /*isSigned*/ true),3811                           APInt(64, 64, /*isSigned*/ true))3812                .getSExtValue(),3813            9223372036854775807);3814  EXPECT_EQ(APIntOps::fshr(APInt(64, 1, /*isSigned*/ true),3815                           APInt(64, 2, /*isSigned*/ true),3816                           APInt(64, 3, /*isSigned*/ true))3817                .getSExtValue(),3818            2305843009213693952);3819  EXPECT_EQ(APIntOps::fshr(APInt(16, -2, /*isSigned*/ true),3820                           APInt(16, -1, /*isSigned*/ true),3821                           APInt(16, 3, /*isSigned*/ true))3822                .getSExtValue(),3823            -8193);3824}3825 3826TEST(APIntTest, clmul) {3827  EXPECT_EQ(APIntOps::clmul(APInt(4, 1), APInt(4, 2)).getZExtValue(), 2U);3828  EXPECT_EQ(APIntOps::clmul(APInt(4, 5), APInt(4, 6)).getZExtValue(), 14U);3829  EXPECT_EQ(APIntOps::clmul(APInt(4, -4, /*isSigned*/ true),3830                            APInt(4, 2, /*isSigned*/ false))3831                .getSExtValue(),3832            -8);3833  EXPECT_EQ(APIntOps::clmul(APInt(4, -4, /*isSigned*/ true),3834                            APInt(4, -5, /*isSigned*/ true))3835                .getSExtValue(),3836            4);3837  EXPECT_EQ(APIntOps::clmul(APInt(8, 0), APInt(8, 255)).getZExtValue(), 0U);3838  EXPECT_EQ(APIntOps::clmul(APInt(8, 15), APInt(8, 15)).getZExtValue(), 85U);3839  EXPECT_EQ(APIntOps::clmul(APInt(8, 1), APInt(8, 2)).getZExtValue(), 2U);3840  EXPECT_EQ(APIntOps::clmul(APInt(64, 0, /*isSigned*/ true),3841                            APInt(64, 9223372036854775807, /*isSigned*/ true))3842                .getSExtValue(),3843            0);3844  EXPECT_EQ(APIntOps::clmul(APInt(64, 1, /*isSigned*/ true),3845                            APInt(64, 2, /*isSigned*/ true))3846                .getSExtValue(),3847            2);3848  EXPECT_EQ(APIntOps::clmul(APInt(16, -2, /*isSigned*/ true),3849                            APInt(16, -1, /*isSigned*/ true))3850                .getSExtValue(),3851            -21846);3852}3853 3854TEST(APIntTest, clmulr) {3855  EXPECT_EQ(APIntOps::clmulr(APInt(4, 1), APInt(4, 2)).getZExtValue(), 0U);3856  EXPECT_EQ(APIntOps::clmulr(APInt(4, 5), APInt(4, 6)).getZExtValue(), 3U);3857  EXPECT_EQ(APIntOps::clmulr(APInt(4, -4, /*isSigned*/ true),3858                             APInt(4, 2, /*isSigned*/ false))3859                .getSExtValue(),3860            3);3861  EXPECT_EQ(APIntOps::clmulr(APInt(4, -4, /*isSigned*/ true),3862                             APInt(4, -5, /*isSigned*/ true))3863                .getSExtValue(),3864            -2);3865  EXPECT_EQ(APIntOps::clmulr(APInt(8, 0), APInt(8, 255)).getZExtValue(), 0U);3866  EXPECT_EQ(APIntOps::clmulr(APInt(8, 15), APInt(8, 15)).getZExtValue(), 0U);3867  EXPECT_EQ(APIntOps::clmulr(APInt(8, 1), APInt(8, 2)).getZExtValue(), 0U);3868  EXPECT_EQ(APIntOps::clmulr(APInt(64, 0, /*isSigned*/ true),3869                             APInt(64, 9223372036854775807, /*isSigned*/ true))3870                .getSExtValue(),3871            0);3872  EXPECT_EQ(APIntOps::clmulr(APInt(64, 1, /*isSigned*/ true),3873                             APInt(64, 2, /*isSigned*/ true))3874                .getSExtValue(),3875            0);3876  EXPECT_EQ(APIntOps::clmulr(APInt(16, -2, /*isSigned*/ true),3877                             APInt(16, -1, /*isSigned*/ true))3878                .getSExtValue(),3879            -21845);3880}3881 3882TEST(APIntTest, clmulh) {3883  EXPECT_EQ(APIntOps::clmulh(APInt(4, 1), APInt(4, 2)).getZExtValue(), 0U);3884  EXPECT_EQ(APIntOps::clmulh(APInt(4, 5), APInt(4, 6)).getZExtValue(), 1U);3885  EXPECT_EQ(APIntOps::clmulh(APInt(4, -4, /*isSigned*/ true),3886                             APInt(4, 2, /*isSigned*/ false))3887                .getSExtValue(),3888            1);3889  EXPECT_EQ(APIntOps::clmulh(APInt(4, -4, /*isSigned*/ true),3890                             APInt(4, -5, /*isSigned*/ true))3891                .getSExtValue(),3892            7);3893  EXPECT_EQ(APIntOps::clmulh(APInt(8, 0), APInt(8, 255)).getZExtValue(), 0U);3894  EXPECT_EQ(APIntOps::clmulh(APInt(8, 15), APInt(8, 15)).getZExtValue(), 0U);3895  EXPECT_EQ(APIntOps::clmulh(APInt(8, 1), APInt(8, 2)).getZExtValue(), 0U);3896  EXPECT_EQ(APIntOps::clmulh(APInt(64, 0, /*isSigned*/ true),3897                             APInt(64, 9223372036854775807, /*isSigned*/ true))3898                .getSExtValue(),3899            0);3900  EXPECT_EQ(APIntOps::clmulh(APInt(64, 1, /*isSigned*/ true),3901                             APInt(64, 2, /*isSigned*/ true))3902                .getSExtValue(),3903            0);3904  EXPECT_EQ(APIntOps::clmulh(APInt(16, -2, /*isSigned*/ true),3905                             APInt(16, -1, /*isSigned*/ true))3906                .getSExtValue(),3907            21845);3908}3909} // end anonymous namespace3910