llvm/unittests/Support/KnownBitsTest.cpp

   1 //===- llvm/unittest/Support/KnownBitsTest.cpp - KnownBits tests ----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements unit tests for KnownBits functions.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Support/KnownBits.h"
  14 #include "KnownBitsTest.h"
  15 #include "gtest/gtest.h"
  16
  17 using namespace llvm;
  18
  19 namespace {
  20
  21 TEST(KnownBitsTest, AddCarryExhaustive) {
  22   unsigned Bits = 4;
  23   ForeachKnownBits(Bits, [&](const KnownBits &Known1) {
  24     ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
  25       ForeachKnownBits(1, [&](const KnownBits &KnownCarry) {
  26         // Explicitly compute known bits of the addition by trying all
  27         // possibilities.
  28         KnownBits Known(Bits);
  29         Known.Zero.setAllBits();
  30         Known.One.setAllBits();
  31         ForeachNumInKnownBits(Known1, [&](const APInt &N1) {
  32           ForeachNumInKnownBits(Known2, [&](const APInt &N2) {
  33             ForeachNumInKnownBits(KnownCarry, [&](const APInt &Carry) {
  34               APInt Add = N1 + N2;
  35               if (Carry.getBoolValue())
  36                 ++Add;
  37
  38               Known.One &= Add;
  39               Known.Zero &= ~Add;
  40             });
  41           });
  42         });
  43
  44         KnownBits KnownComputed = KnownBits::computeForAddCarry(
  45             Known1, Known2, KnownCarry);
  46         EXPECT_EQ(Known.Zero, KnownComputed.Zero);
  47         EXPECT_EQ(Known.One, KnownComputed.One);
  48       });
  49     });
  50   });
  51 }
  52
  53 static void TestAddSubExhaustive(bool IsAdd) {
  54   unsigned Bits = 4;
  55   ForeachKnownBits(Bits, [&](const KnownBits &Known1) {
  56     ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
  57       KnownBits Known(Bits), KnownNSW(Bits);
  58       Known.Zero.setAllBits();
  59       Known.One.setAllBits();
  60       KnownNSW.Zero.setAllBits();
  61       KnownNSW.One.setAllBits();
  62
  63       ForeachNumInKnownBits(Known1, [&](const APInt &N1) {
  64         ForeachNumInKnownBits(Known2, [&](const APInt &N2) {
  65           bool Overflow;
  66           APInt Res;
  67           if (IsAdd)
  68             Res = N1.sadd_ov(N2, Overflow);
  69           else
  70             Res = N1.ssub_ov(N2, Overflow);
  71
  72           Known.One &= Res;
  73           Known.Zero &= ~Res;
  74
  75           if (!Overflow) {
  76             KnownNSW.One &= Res;
  77             KnownNSW.Zero &= ~Res;
  78           }
  79         });
  80       });
  81
  82       KnownBits KnownComputed = KnownBits::computeForAddSub(
  83           IsAdd, /*NSW*/false, Known1, Known2);
  84       EXPECT_EQ(Known.Zero, KnownComputed.Zero);
  85       EXPECT_EQ(Known.One, KnownComputed.One);
  86
  87       // The NSW calculation is not precise, only check that it's
  88       // conservatively correct.
  89       KnownBits KnownNSWComputed = KnownBits::computeForAddSub(
  90           IsAdd, /*NSW*/true, Known1, Known2);
  91       EXPECT_TRUE(KnownNSWComputed.Zero.isSubsetOf(KnownNSW.Zero));
  92       EXPECT_TRUE(KnownNSWComputed.One.isSubsetOf(KnownNSW.One));
  93     });
  94   });
  95 }
  96
  97 TEST(KnownBitsTest, AddSubExhaustive) {
  98   TestAddSubExhaustive(true);
  99   TestAddSubExhaustive(false);
 100 }
 101
 102 TEST(KnownBitsTest, BinaryExhaustive) {
 103   unsigned Bits = 4;
 104   ForeachKnownBits(Bits, [&](const KnownBits &Known1) {
 105     ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
 106       KnownBits KnownAnd(Bits);
 107       KnownAnd.Zero.setAllBits();
 108       KnownAnd.One.setAllBits();
 109       KnownBits KnownOr(KnownAnd);
 110       KnownBits KnownXor(KnownAnd);
 111       KnownBits KnownUMax(KnownAnd);
 112       KnownBits KnownUMin(KnownAnd);
 113       KnownBits KnownSMax(KnownAnd);
 114       KnownBits KnownSMin(KnownAnd);
 115       KnownBits KnownMul(KnownAnd);
 116       KnownBits KnownMulHS(KnownAnd);
 117       KnownBits KnownMulHU(KnownAnd);
 118       KnownBits KnownUDiv(KnownAnd);
 119       KnownBits KnownURem(KnownAnd);
 120       KnownBits KnownSRem(KnownAnd);
 121       KnownBits KnownShl(KnownAnd);
 122       KnownBits KnownLShr(KnownAnd);
 123       KnownBits KnownAShr(KnownAnd);
 124
 125       ForeachNumInKnownBits(Known1, [&](const APInt &N1) {
 126         ForeachNumInKnownBits(Known2, [&](const APInt &N2) {
 127           APInt Res;
 128
 129           Res = N1 & N2;
 130           KnownAnd.One &= Res;
 131           KnownAnd.Zero &= ~Res;
 132
 133           Res = N1 | N2;
 134           KnownOr.One &= Res;
 135           KnownOr.Zero &= ~Res;
 136
 137           Res = N1 ^ N2;
 138           KnownXor.One &= Res;
 139           KnownXor.Zero &= ~Res;
 140
 141           Res = APIntOps::umax(N1, N2);
 142           KnownUMax.One &= Res;
 143           KnownUMax.Zero &= ~Res;
 144
 145           Res = APIntOps::umin(N1, N2);
 146           KnownUMin.One &= Res;
 147           KnownUMin.Zero &= ~Res;
 148
 149           Res = APIntOps::smax(N1, N2);
 150           KnownSMax.One &= Res;
 151           KnownSMax.Zero &= ~Res;
 152
 153           Res = APIntOps::smin(N1, N2);
 154           KnownSMin.One &= Res;
 155           KnownSMin.Zero &= ~Res;
 156
 157           Res = N1 * N2;
 158           KnownMul.One &= Res;
 159           KnownMul.Zero &= ~Res;
 160
 161           Res = (N1.sext(2 * Bits) * N2.sext(2 * Bits)).extractBits(Bits, Bits);
 162           KnownMulHS.One &= Res;
 163           KnownMulHS.Zero &= ~Res;
 164
 165           Res = (N1.zext(2 * Bits) * N2.zext(2 * Bits)).extractBits(Bits, Bits);
 166           KnownMulHU.One &= Res;
 167           KnownMulHU.Zero &= ~Res;
 168
 169           if (!N2.isZero()) {
 170             Res = N1.udiv(N2);
 171             KnownUDiv.One &= Res;
 172             KnownUDiv.Zero &= ~Res;
 173
 174             Res = N1.urem(N2);
 175             KnownURem.One &= Res;
 176             KnownURem.Zero &= ~Res;
 177
 178             Res = N1.srem(N2);
 179             KnownSRem.One &= Res;
 180             KnownSRem.Zero &= ~Res;
 181           }
 182
 183           if (N2.ult(1ULL << N1.getBitWidth())) {
 184             Res = N1.shl(N2);
 185             KnownShl.One &= Res;
 186             KnownShl.Zero &= ~Res;
 187
 188             Res = N1.lshr(N2);
 189             KnownLShr.One &= Res;
 190             KnownLShr.Zero &= ~Res;
 191
 192             Res = N1.ashr(N2);
 193             KnownAShr.One &= Res;
 194             KnownAShr.Zero &= ~Res;
 195           } else {
 196             KnownShl.resetAll();
 197             KnownLShr.resetAll();
 198             KnownAShr.resetAll();
 199           }
 200         });
 201       });
 202
 203       KnownBits ComputedAnd = Known1 & Known2;
 204       EXPECT_EQ(KnownAnd.Zero, ComputedAnd.Zero);
 205       EXPECT_EQ(KnownAnd.One, ComputedAnd.One);
 206
 207       KnownBits ComputedOr = Known1 | Known2;
 208       EXPECT_EQ(KnownOr.Zero, ComputedOr.Zero);
 209       EXPECT_EQ(KnownOr.One, ComputedOr.One);
 210
 211       KnownBits ComputedXor = Known1 ^ Known2;
 212       EXPECT_EQ(KnownXor.Zero, ComputedXor.Zero);
 213       EXPECT_EQ(KnownXor.One, ComputedXor.One);
 214
 215       KnownBits ComputedUMax = KnownBits::umax(Known1, Known2);
 216       EXPECT_EQ(KnownUMax.Zero, ComputedUMax.Zero);
 217       EXPECT_EQ(KnownUMax.One, ComputedUMax.One);
 218
 219       KnownBits ComputedUMin = KnownBits::umin(Known1, Known2);
 220       EXPECT_EQ(KnownUMin.Zero, ComputedUMin.Zero);
 221       EXPECT_EQ(KnownUMin.One, ComputedUMin.One);
 222
 223       KnownBits ComputedSMax = KnownBits::smax(Known1, Known2);
 224       EXPECT_EQ(KnownSMax.Zero, ComputedSMax.Zero);
 225       EXPECT_EQ(KnownSMax.One, ComputedSMax.One);
 226
 227       KnownBits ComputedSMin = KnownBits::smin(Known1, Known2);
 228       EXPECT_EQ(KnownSMin.Zero, ComputedSMin.Zero);
 229       EXPECT_EQ(KnownSMin.One, ComputedSMin.One);
 230
 231       // The following are conservatively correct, but not guaranteed to be
 232       // precise.
 233       KnownBits ComputedMul = KnownBits::mul(Known1, Known2);
 234       EXPECT_TRUE(ComputedMul.Zero.isSubsetOf(KnownMul.Zero));
 235       EXPECT_TRUE(ComputedMul.One.isSubsetOf(KnownMul.One));
 236
 237       KnownBits ComputedMulHS = KnownBits::mulhs(Known1, Known2);
 238       EXPECT_TRUE(ComputedMulHS.Zero.isSubsetOf(KnownMulHS.Zero));
 239       EXPECT_TRUE(ComputedMulHS.One.isSubsetOf(KnownMulHS.One));
 240
 241       KnownBits ComputedMulHU = KnownBits::mulhu(Known1, Known2);
 242       EXPECT_TRUE(ComputedMulHU.Zero.isSubsetOf(KnownMulHU.Zero));
 243       EXPECT_TRUE(ComputedMulHU.One.isSubsetOf(KnownMulHU.One));
 244
 245       KnownBits ComputedUDiv = KnownBits::udiv(Known1, Known2);
 246       EXPECT_TRUE(ComputedUDiv.Zero.isSubsetOf(KnownUDiv.Zero));
 247       EXPECT_TRUE(ComputedUDiv.One.isSubsetOf(KnownUDiv.One));
 248
 249       KnownBits ComputedURem = KnownBits::urem(Known1, Known2);
 250       EXPECT_TRUE(ComputedURem.Zero.isSubsetOf(KnownURem.Zero));
 251       EXPECT_TRUE(ComputedURem.One.isSubsetOf(KnownURem.One));
 252
 253       KnownBits ComputedSRem = KnownBits::srem(Known1, Known2);
 254       EXPECT_TRUE(ComputedSRem.Zero.isSubsetOf(KnownSRem.Zero));
 255       EXPECT_TRUE(ComputedSRem.One.isSubsetOf(KnownSRem.One));
 256
 257       KnownBits ComputedShl = KnownBits::shl(Known1, Known2);
 258       EXPECT_TRUE(ComputedShl.Zero.isSubsetOf(KnownShl.Zero));
 259       EXPECT_TRUE(ComputedShl.One.isSubsetOf(KnownShl.One));
 260
 261       KnownBits ComputedLShr = KnownBits::lshr(Known1, Known2);
 262       EXPECT_TRUE(ComputedLShr.Zero.isSubsetOf(KnownLShr.Zero));
 263       EXPECT_TRUE(ComputedLShr.One.isSubsetOf(KnownLShr.One));
 264
 265       KnownBits ComputedAShr = KnownBits::ashr(Known1, Known2);
 266       EXPECT_TRUE(ComputedAShr.Zero.isSubsetOf(KnownAShr.Zero));
 267       EXPECT_TRUE(ComputedAShr.One.isSubsetOf(KnownAShr.One));
 268     });
 269   });
 270
 271   // Also test 'unary' binary cases where the same argument is repeated.
 272   ForeachKnownBits(Bits, [&](const KnownBits &Known) {
 273     KnownBits KnownMul(Bits);
 274     KnownMul.Zero.setAllBits();
 275     KnownMul.One.setAllBits();
 276
 277     ForeachNumInKnownBits(Known, [&](const APInt &N) {
 278       APInt Res = N * N;
 279       KnownMul.One &= Res;
 280       KnownMul.Zero &= ~Res;
 281     });
 282
 283     KnownBits ComputedMul = KnownBits::mul(Known, Known, /*SelfMultiply*/ true);
 284     EXPECT_TRUE(ComputedMul.Zero.isSubsetOf(KnownMul.Zero));
 285     EXPECT_TRUE(ComputedMul.One.isSubsetOf(KnownMul.One));
 286   });
 287 }
 288
 289 TEST(KnownBitsTest, UnaryExhaustive) {
 290   unsigned Bits = 4;
 291   ForeachKnownBits(Bits, [&](const KnownBits &Known) {
 292     KnownBits KnownAbs(Bits);
 293     KnownAbs.Zero.setAllBits();
 294     KnownAbs.One.setAllBits();
 295     KnownBits KnownAbsPoison(KnownAbs);
 296
 297     ForeachNumInKnownBits(Known, [&](const APInt &N) {
 298       APInt Res = N.abs();
 299       KnownAbs.One &= Res;
 300       KnownAbs.Zero &= ~Res;
 301
 302       if (!N.isMinSignedValue()) {
 303         KnownAbsPoison.One &= Res;
 304         KnownAbsPoison.Zero &= ~Res;
 305       }
 306     });
 307
 308     // abs() is conservatively correct, but not guaranteed to be precise.
 309     KnownBits ComputedAbs = Known.abs();
 310     EXPECT_TRUE(ComputedAbs.Zero.isSubsetOf(KnownAbs.Zero));
 311     EXPECT_TRUE(ComputedAbs.One.isSubsetOf(KnownAbs.One));
 312
 313     KnownBits ComputedAbsPoison = Known.abs(true);
 314     EXPECT_TRUE(ComputedAbsPoison.Zero.isSubsetOf(KnownAbsPoison.Zero));
 315     EXPECT_TRUE(ComputedAbsPoison.One.isSubsetOf(KnownAbsPoison.One));
 316   });
 317 }
 318
 319 TEST(KnownBitsTest, ICmpExhaustive) {
 320   unsigned Bits = 4;
 321   ForeachKnownBits(Bits, [&](const KnownBits &Known1) {
 322     ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
 323       bool AllEQ = true, NoneEQ = true;
 324       bool AllNE = true, NoneNE = true;
 325       bool AllUGT = true, NoneUGT = true;
 326       bool AllUGE = true, NoneUGE = true;
 327       bool AllULT = true, NoneULT = true;
 328       bool AllULE = true, NoneULE = true;
 329       bool AllSGT = true, NoneSGT = true;
 330       bool AllSGE = true, NoneSGE = true;
 331       bool AllSLT = true, NoneSLT = true;
 332       bool AllSLE = true, NoneSLE = true;
 333
 334       ForeachNumInKnownBits(Known1, [&](const APInt &N1) {
 335         ForeachNumInKnownBits(Known2, [&](const APInt &N2) {
 336           AllEQ &= N1.eq(N2);
 337           AllNE &= N1.ne(N2);
 338           AllUGT &= N1.ugt(N2);
 339           AllUGE &= N1.uge(N2);
 340           AllULT &= N1.ult(N2);
 341           AllULE &= N1.ule(N2);
 342           AllSGT &= N1.sgt(N2);
 343           AllSGE &= N1.sge(N2);
 344           AllSLT &= N1.slt(N2);
 345           AllSLE &= N1.sle(N2);
 346           NoneEQ &= !N1.eq(N2);
 347           NoneNE &= !N1.ne(N2);
 348           NoneUGT &= !N1.ugt(N2);
 349           NoneUGE &= !N1.uge(N2);
 350           NoneULT &= !N1.ult(N2);
 351           NoneULE &= !N1.ule(N2);
 352           NoneSGT &= !N1.sgt(N2);
 353           NoneSGE &= !N1.sge(N2);
 354           NoneSLT &= !N1.slt(N2);
 355           NoneSLE &= !N1.sle(N2);
 356         });
 357       });
 358
 359       Optional<bool> KnownEQ = KnownBits::eq(Known1, Known2);
 360       Optional<bool> KnownNE = KnownBits::ne(Known1, Known2);
 361       Optional<bool> KnownUGT = KnownBits::ugt(Known1, Known2);
 362       Optional<bool> KnownUGE = KnownBits::uge(Known1, Known2);
 363       Optional<bool> KnownULT = KnownBits::ult(Known1, Known2);
 364       Optional<bool> KnownULE = KnownBits::ule(Known1, Known2);
 365       Optional<bool> KnownSGT = KnownBits::sgt(Known1, Known2);
 366       Optional<bool> KnownSGE = KnownBits::sge(Known1, Known2);
 367       Optional<bool> KnownSLT = KnownBits::slt(Known1, Known2);
 368       Optional<bool> KnownSLE = KnownBits::sle(Known1, Known2);
 369
 370       EXPECT_EQ(AllEQ || NoneEQ, KnownEQ.hasValue());
 371       EXPECT_EQ(AllNE || NoneNE, KnownNE.hasValue());
 372       EXPECT_EQ(AllUGT || NoneUGT, KnownUGT.hasValue());
 373       EXPECT_EQ(AllUGE || NoneUGE, KnownUGE.hasValue());
 374       EXPECT_EQ(AllULT || NoneULT, KnownULT.hasValue());
 375       EXPECT_EQ(AllULE || NoneULE, KnownULE.hasValue());
 376       EXPECT_EQ(AllSGT || NoneSGT, KnownSGT.hasValue());
 377       EXPECT_EQ(AllSGE || NoneSGE, KnownSGE.hasValue());
 378       EXPECT_EQ(AllSLT || NoneSLT, KnownSLT.hasValue());
 379       EXPECT_EQ(AllSLE || NoneSLE, KnownSLE.hasValue());
 380
 381       EXPECT_EQ(AllEQ, KnownEQ.hasValue() && KnownEQ.getValue());
 382       EXPECT_EQ(AllNE, KnownNE.hasValue() && KnownNE.getValue());
 383       EXPECT_EQ(AllUGT, KnownUGT.hasValue() && KnownUGT.getValue());
 384       EXPECT_EQ(AllUGE, KnownUGE.hasValue() && KnownUGE.getValue());
 385       EXPECT_EQ(AllULT, KnownULT.hasValue() && KnownULT.getValue());
 386       EXPECT_EQ(AllULE, KnownULE.hasValue() && KnownULE.getValue());
 387       EXPECT_EQ(AllSGT, KnownSGT.hasValue() && KnownSGT.getValue());
 388       EXPECT_EQ(AllSGE, KnownSGE.hasValue() && KnownSGE.getValue());
 389       EXPECT_EQ(AllSLT, KnownSLT.hasValue() && KnownSLT.getValue());
 390       EXPECT_EQ(AllSLE, KnownSLE.hasValue() && KnownSLE.getValue());
 391
 392       EXPECT_EQ(NoneEQ, KnownEQ.hasValue() && !KnownEQ.getValue());
 393       EXPECT_EQ(NoneNE, KnownNE.hasValue() && !KnownNE.getValue());
 394       EXPECT_EQ(NoneUGT, KnownUGT.hasValue() && !KnownUGT.getValue());
 395       EXPECT_EQ(NoneUGE, KnownUGE.hasValue() && !KnownUGE.getValue());
 396       EXPECT_EQ(NoneULT, KnownULT.hasValue() && !KnownULT.getValue());
 397       EXPECT_EQ(NoneULE, KnownULE.hasValue() && !KnownULE.getValue());
 398       EXPECT_EQ(NoneSGT, KnownSGT.hasValue() && !KnownSGT.getValue());
 399       EXPECT_EQ(NoneSGE, KnownSGE.hasValue() && !KnownSGE.getValue());
 400       EXPECT_EQ(NoneSLT, KnownSLT.hasValue() && !KnownSLT.getValue());
 401       EXPECT_EQ(NoneSLE, KnownSLE.hasValue() && !KnownSLE.getValue());
 402     });
 403   });
 404 }
 405
 406 TEST(KnownBitsTest, GetMinMaxVal) {
 407   unsigned Bits = 4;
 408   ForeachKnownBits(Bits, [&](const KnownBits &Known) {
 409     APInt Min = APInt::getMaxValue(Bits);
 410     APInt Max = APInt::getMinValue(Bits);
 411     ForeachNumInKnownBits(Known, [&](const APInt &N) {
 412       Min = APIntOps::umin(Min, N);
 413       Max = APIntOps::umax(Max, N);
 414     });
 415     EXPECT_EQ(Min, Known.getMinValue());
 416     EXPECT_EQ(Max, Known.getMaxValue());
 417   });
 418 }
 419
 420 TEST(KnownBitsTest, GetSignedMinMaxVal) {
 421   unsigned Bits = 4;
 422   ForeachKnownBits(Bits, [&](const KnownBits &Known) {
 423     APInt Min = APInt::getSignedMaxValue(Bits);
 424     APInt Max = APInt::getSignedMinValue(Bits);
 425     ForeachNumInKnownBits(Known, [&](const APInt &N) {
 426       Min = APIntOps::smin(Min, N);
 427       Max = APIntOps::smax(Max, N);
 428     });
 429     EXPECT_EQ(Min, Known.getSignedMinValue());
 430     EXPECT_EQ(Max, Known.getSignedMaxValue());
 431   });
 432 }
 433
 434 TEST(KnownBitsTest, CountMaxActiveBits) {
 435   unsigned Bits = 4;
 436   ForeachKnownBits(Bits, [&](const KnownBits &Known) {
 437     unsigned Expected = 0;
 438     ForeachNumInKnownBits(Known, [&](const APInt &N) {
 439       Expected = std::max(Expected, N.getActiveBits());
 440     });
 441     EXPECT_EQ(Expected, Known.countMaxActiveBits());
 442   });
 443 }
 444
 445 TEST(KnownBitsTest, CountMaxSignificantBits) {
 446   unsigned Bits = 4;
 447   ForeachKnownBits(Bits, [&](const KnownBits &Known) {
 448     unsigned Expected = 0;
 449     ForeachNumInKnownBits(Known, [&](const APInt &N) {
 450       Expected = std::max(Expected, N.getSignificantBits());
 451     });
 452     EXPECT_EQ(Expected, Known.countMaxSignificantBits());
 453   });
 454 }
 455
 456 TEST(KnownBitsTest, SExtOrTrunc) {
 457   const unsigned NarrowerSize = 4;
 458   const unsigned BaseSize = 6;
 459   const unsigned WiderSize = 8;
 460   APInt NegativeFitsNarrower(BaseSize, -4, /*isSigned*/ true);
 461   APInt NegativeDoesntFitNarrower(BaseSize, -28, /*isSigned*/ true);
 462   APInt PositiveFitsNarrower(BaseSize, 14);
 463   APInt PositiveDoesntFitNarrower(BaseSize, 36);
 464   auto InitKnownBits = [&](KnownBits &Res, const APInt &Input) {
 465     Res = KnownBits(Input.getBitWidth());
 466     Res.One = Input;
 467     Res.Zero = ~Input;
 468   };
 469
 470   for (unsigned Size : {NarrowerSize, BaseSize, WiderSize}) {
 471     for (const APInt &Input :
 472          {NegativeFitsNarrower, NegativeDoesntFitNarrower, PositiveFitsNarrower,
 473           PositiveDoesntFitNarrower}) {
 474       KnownBits Test;
 475       InitKnownBits(Test, Input);
 476       KnownBits Baseline;
 477       InitKnownBits(Baseline, Input.sextOrTrunc(Size));
 478       Test = Test.sextOrTrunc(Size);
 479       EXPECT_EQ(Test.One, Baseline.One);
 480       EXPECT_EQ(Test.Zero, Baseline.Zero);
 481     }
 482   }
 483 }
 484
 485 TEST(KnownBitsTest, SExtInReg) {
 486   unsigned Bits = 4;
 487   for (unsigned FromBits = 1; FromBits <= Bits; ++FromBits) {
 488     ForeachKnownBits(Bits, [&](const KnownBits &Known) {
 489       APInt CommonOne = APInt::getAllOnes(Bits);
 490       APInt CommonZero = APInt::getAllOnes(Bits);
 491       unsigned ExtBits = Bits - FromBits;
 492       ForeachNumInKnownBits(Known, [&](const APInt &N) {
 493         APInt Ext = N << ExtBits;
 494         Ext.ashrInPlace(ExtBits);
 495         CommonOne &= Ext;
 496         CommonZero &= ~Ext;
 497       });
 498       KnownBits KnownSExtInReg = Known.sextInReg(FromBits);
 499       EXPECT_EQ(CommonOne, KnownSExtInReg.One);
 500       EXPECT_EQ(CommonZero, KnownSExtInReg.Zero);
 501     });
 502   }
 503 }
 504
 505 TEST(KnownBitsTest, CommonBitsSet) {
 506   unsigned Bits = 4;
 507   ForeachKnownBits(Bits, [&](const KnownBits &Known1) {
 508     ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
 509       bool HasCommonBitsSet = false;
 510       ForeachNumInKnownBits(Known1, [&](const APInt &N1) {
 511         ForeachNumInKnownBits(Known2, [&](const APInt &N2) {
 512           HasCommonBitsSet |= N1.intersects(N2);
 513         });
 514       });
 515       EXPECT_EQ(!HasCommonBitsSet,
 516                 KnownBits::haveNoCommonBitsSet(Known1, Known2));
 517     });
 518   });
 519 }
 520
 521 } // end anonymous namespace