Lines Matching defs:ConstantRange
1 //===- ConstantRangeTest.cpp - ConstantRange tests ------------------------===//
9 #include "llvm/IR/ConstantRange.h"
24 static ConstantRange Full;
25 static ConstantRange Empty;
26 static ConstantRange One;
27 static ConstantRange Some;
28 static ConstantRange Wrap;
44 // Enforce ConstantRange invariant.
48 ConstantRange CR(APInt(Bits, Lo), APInt(Bits, Hi));
65 EnumerateConstantRanges(Bits, [&](const ConstantRange &CR1) {
67 Bits, [&](const ConstantRange &CR2) { TestFn(CR1, CR2); });
73 static void ForeachNumInConstantRange(const ConstantRange &CR, Fn TestFn) {
81 using PreferFn = llvm::function_ref<bool(const ConstantRange &,
82 const ConstantRange &)>;
84 bool PreferSmallest(const ConstantRange &CR1, const ConstantRange &CR2) {
88 bool PreferSmallestUnsigned(const ConstantRange &CR1,
89 const ConstantRange &CR2) {
95 bool PreferSmallestSigned(const ConstantRange &CR1, const ConstantRange &CR2) {
101 bool PreferSmallestNonFullUnsigned(const ConstantRange &CR1,
102 const ConstantRange &CR2) {
108 bool PreferSmallestNonFullSigned(const ConstantRange &CR1,
109 const ConstantRange &CR2) {
115 testing::AssertionResult rangeContains(const ConstantRange &CR, const APInt &N,
116 ArrayRef<ConstantRange> Inputs) {
122 for (const ConstantRange &Input : Inputs)
130 static void TestRange(const ConstantRange &CR, const SmallBitVector &Elems,
131 PreferFn PreferenceFn, ArrayRef<ConstantRange> Inputs,
149 auto NotPreferred = [&](const ConstantRange &PossibleCR) {
155 for (const ConstantRange &Input : Inputs)
171 ConstantRange PossibleCR =
172 ConstantRange::getNonEmpty(APInt(BitWidth, Elem),
183 EXPECT_TRUE(NotPreferred(ConstantRange::getFull(BitWidth)));
186 using UnaryRangeFn = llvm::function_ref<ConstantRange(const ConstantRange &)>;
191 EnumerateInterestingConstantRanges([&](const ConstantRange &CR) {
201 using BinaryRangeFn = llvm::function_ref<ConstantRange(const ConstantRange &,
202 const ConstantRange &)>;
205 using BinaryCheckFn = llvm::function_ref<bool(const ConstantRange &,
206 const ConstantRange &)>;
208 static bool CheckAll(const ConstantRange &, const ConstantRange &) {
212 static bool CheckCorrectnessOnly(const ConstantRange &, const ConstantRange &) {
216 static bool CheckSingleElementsOnly(const ConstantRange &CR1,
217 const ConstantRange &CR2) {
221 static bool CheckNonWrappedOnly(const ConstantRange &CR1,
222 const ConstantRange &CR2) {
226 static bool CheckNonSignWrappedOnly(const ConstantRange &CR1,
227 const ConstantRange &CR2) {
232 CheckNoSignedWrappedLHSAndNoWrappedRHSOnly(const ConstantRange &CR1,
233 const ConstantRange &CR2) {
237 static bool CheckNonWrappedOrSignWrappedOnly(const ConstantRange &CR1,
238 const ConstantRange &CR2) {
249 [&](const ConstantRange &CR1, const ConstantRange &CR2) {
262 ConstantRange ConstantRangeTest::Full(16, true);
263 ConstantRange ConstantRangeTest::Empty(16, false);
264 ConstantRange ConstantRangeTest::One(APInt(16, 0xa));
265 ConstantRange ConstantRangeTest::Some(APInt(16, 0xa), APInt(16, 0xaaa));
266 ConstantRange ConstantRangeTest::Wrap(APInt(16, 0xaaa), APInt(16, 0xa));
349 ConstantRange OneInverse = One.inverse();
381 EXPECT_EQ(ConstantRange(APInt(4, 7), APInt(4, 0)).getSignedMax(),
392 EXPECT_FALSE(ConstantRange(APInt(8, 127), APInt(8, 128)).isSignWrappedSet());
393 EXPECT_TRUE(ConstantRange(APInt(8, 127), APInt(8, 129)).isSignWrappedSet());
394 EXPECT_FALSE(ConstantRange(APInt(8, 128), APInt(8, 129)).isSignWrappedSet());
395 EXPECT_TRUE(ConstantRange(APInt(8, 10), APInt(8, 9)).isSignWrappedSet());
396 EXPECT_TRUE(ConstantRange(APInt(8, 10), APInt(8, 250)).isSignWrappedSet());
397 EXPECT_FALSE(ConstantRange(APInt(8, 250), APInt(8, 10)).isSignWrappedSet());
398 EXPECT_FALSE(ConstantRange(APInt(8, 250), APInt(8, 251)).isSignWrappedSet());
415 ConstantRange CR1(APInt(8, 42), APInt::getMinValue(8));
419 ConstantRange CR2(APInt(8, 42), APInt::getSignedMinValue(8));
425 ConstantRange TFull = Full.truncate(10);
426 ConstantRange TEmpty = Empty.truncate(10);
427 ConstantRange TOne = One.truncate(10);
428 ConstantRange TSome = Some.truncate(10);
429 ConstantRange TWrap = Wrap.truncate(10);
432 EXPECT_EQ(TOne, ConstantRange(One.getLower().trunc(10),
438 ConstantRange TwoFive(APInt(3, 2), APInt(3, 5));
439 EXPECT_EQ(TwoFive.truncate(2), ConstantRange(APInt(2, 2), APInt(2, 1)));
442 ConstantRange TwoSix(APInt(3, 2), APInt(3, 6));
446 ConstantRange FiveSeven(APInt(3, 5), APInt(3, 7));
447 EXPECT_EQ(FiveSeven.truncate(2), ConstantRange(APInt(2, 1), APInt(2, 3)));
450 ConstantRange SevenOne(APInt(3, 7), APInt(3, 1));
451 EXPECT_EQ(SevenOne.truncate(2), ConstantRange(APInt(2, 3), APInt(2, 1)));
455 ConstantRange ZFull = Full.zeroExtend(20);
456 ConstantRange ZEmpty = Empty.zeroExtend(20);
457 ConstantRange ZOne = One.zeroExtend(20);
458 ConstantRange ZSome = Some.zeroExtend(20);
459 ConstantRange ZWrap = Wrap.zeroExtend(20);
460 EXPECT_EQ(ZFull, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
462 EXPECT_EQ(ZOne, ConstantRange(One.getLower().zext(20),
464 EXPECT_EQ(ZSome, ConstantRange(Some.getLower().zext(20),
466 EXPECT_EQ(ZWrap, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
469 ConstantRange FiveZero(APInt(3, 5), APInt(3, 0));
470 EXPECT_EQ(FiveZero.zeroExtend(7), ConstantRange(APInt(7, 5), APInt(7, 8)));
474 ConstantRange SFull = Full.signExtend(20);
475 ConstantRange SEmpty = Empty.signExtend(20);
476 ConstantRange SOne = One.signExtend(20);
477 ConstantRange SSome = Some.signExtend(20);
478 ConstantRange SWrap = Wrap.signExtend(20);
479 EXPECT_EQ(SFull, ConstantRange(APInt(20, (uint64_t)INT16_MIN, true),
482 EXPECT_EQ(SOne, ConstantRange(One.getLower().sext(20),
484 EXPECT_EQ(SSome, ConstantRange(Some.getLower().sext(20),
486 EXPECT_EQ(SWrap, ConstantRange(APInt(20, (uint64_t)INT16_MIN, true),
489 EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, 140)).signExtend(16),
490 ConstantRange(APInt(16, -128, true), APInt(16, 128)));
492 EXPECT_EQ(ConstantRange(APInt(16, 0x0200), APInt(16, 0x8000)).signExtend(19),
493 ConstantRange(APInt(19, 0x0200), APInt(19, 0x8000)));
514 ConstantRange LHS(APInt(16, 4), APInt(16, 2));
515 ConstantRange RHS(APInt(16, 6), APInt(16, 5));
519 LHS = ConstantRange(APInt(32, (uint32_t)-2147483646), APInt(32, 3));
520 RHS = ConstantRange(APInt(32, 2), APInt(32, 2147483646));
521 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 2)));
524 LHS = ConstantRange(APInt(32, 2), APInt(32, 0));
525 RHS = ConstantRange(APInt(32, 4), APInt(32, 3));
526 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 2), APInt(32, 0)));
529 LHS = ConstantRange(APInt(32, 2), APInt(32, 0));
530 RHS = ConstantRange(APInt(32, 4), APInt(32, 2));
531 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 4), APInt(32, 0)));
534 LHS = ConstantRange(APInt(32, 4), APInt(32, 2));
535 RHS = ConstantRange(APInt(32, 5), APInt(32, 1));
536 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 5), APInt(32, 1)));
539 LHS = ConstantRange(APInt(32, 2), APInt(32, 0));
540 RHS = ConstantRange(APInt(32, 7), APInt(32, 4));
541 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 7), APInt(32, 4)));
544 LHS = ConstantRange(APInt(32, 4), APInt(32, 2));
545 RHS = ConstantRange(APInt(32, 1), APInt(32, 0));
546 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 4), APInt(32, 2)));
549 LHS = ConstantRange(APInt(32, 15), APInt(32, 0));
550 RHS = ConstantRange(APInt(32, 7), APInt(32, 6));
551 EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 15), APInt(32, 0)));
557 [=](const ConstantRange &CR1, const ConstantRange &CR2) {
565 ConstantRange SmallestCR = OpFn(CR1, CR2, ConstantRange::Smallest);
568 ConstantRange UnsignedCR = OpFn(CR1, CR2, ConstantRange::Unsigned);
571 ConstantRange SignedCR = OpFn(CR1, CR2, ConstantRange::Signed);
574 std::optional<ConstantRange> ExactCR = ExactOpFn(CR1, CR2);
585 [](const ConstantRange &CR1, const ConstantRange &CR2,
586 ConstantRange::PreferredRangeType Type) {
589 [](const ConstantRange &CR1, const ConstantRange &CR2) {
592 [](const ConstantRange &CR1, const ConstantRange &CR2, const APInt &N) {
599 [](const ConstantRange &CR1, const ConstantRange &CR2,
600 ConstantRange::PreferredRangeType Type) {
603 [](const ConstantRange &CR1, const ConstantRange &CR2) {
606 [](const ConstantRange &CR1, const ConstantRange &CR2, const APInt &N) {
613 ConstantRange(APInt(16, 0xaaa), APInt(16, 0xb)));
620 EXPECT_EQ(ConstantRange(APInt(16, 14), APInt(16, 1)).unionWith(
621 ConstantRange(APInt(16, 0), APInt(16, 8))),
622 ConstantRange(APInt(16, 14), APInt(16, 8)));
623 EXPECT_EQ(ConstantRange(APInt(16, 6), APInt(16, 4)).unionWith(
624 ConstantRange(APInt(16, 4), APInt(16, 0))),
625 ConstantRange::getFull(16));
626 EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 0)).unionWith(
627 ConstantRange(APInt(16, 2), APInt(16, 1))),
628 ConstantRange::getFull(16));
637 ConstantRange A(APInt(16, 3), APInt(16, 7));
638 ConstantRange B(APInt(16, 5), APInt(16, 9));
639 ConstantRange C(APInt(16, 3), APInt(16, 5));
640 ConstantRange D(APInt(16, 7), APInt(16, 9));
641 ConstantRange E(APInt(16, 5), APInt(16, 4));
642 ConstantRange F(APInt(16, 7), APInt(16, 3));
649 EnumerateInterestingConstantRanges([&](const ConstantRange &CR) {
660 EnumerateInterestingConstantRanges([&](const ConstantRange &CR) {
675 EnumerateInterestingConstantRanges([&](const ConstantRange &CR) {
686 EnumerateInterestingConstantRanges([&](const ConstantRange &CR) {
703 ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
705 ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
707 ConstantRange(APInt(16, 0x6)));
723 ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));
725 ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));
727 ConstantRange(APInt(16, 0xe)));
730 [](const ConstantRange &CR1, const ConstantRange &CR2) {
745 EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 2)),
747 ConstantRange(APInt(16, INT16_MIN + 1, true),
749 EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 2))
751 ConstantRange(APInt(16, INT16_MIN + 1, true),
753 EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, -1, true), APInt(16, 0)),
755 ConstantRange(APInt(16, INT16_MIN, true), APInt(16, INT16_MAX)));
756 EXPECT_EQ(ConstantRange(APInt(8, 100), APInt(8, 120))
757 .addWithNoWrap(ConstantRange(APInt(8, 120), APInt(8, 123)),
759 ConstantRange(8, false));
760 EXPECT_EQ(ConstantRange(APInt(8, -120, true), APInt(8, -100, true))
762 ConstantRange(APInt(8, -110, true), APInt(8, -100, true)),
764 ConstantRange(8, false));
766 ConstantRange(APInt(8, 0), APInt(8, 101))
767 .addWithNoWrap(ConstantRange(APInt(8, -128, true), APInt(8, 28)),
769 ConstantRange(8, true));
771 ConstantRange(APInt(8, 0), APInt(8, 101))
772 .addWithNoWrap(ConstantRange(APInt(8, -120, true), APInt(8, 29)),
774 ConstantRange(APInt(8, -120, true), APInt(8, -128, true)));
775 EXPECT_EQ(ConstantRange(APInt(8, -50, true), APInt(8, 50))
776 .addWithNoWrap(ConstantRange(APInt(8, 10), APInt(8, 20)),
778 ConstantRange(APInt(8, -40, true), APInt(8, 69)));
779 EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
780 .addWithNoWrap(ConstantRange(APInt(8, -50, true), APInt(8, 50)),
782 ConstantRange(APInt(8, -40, true), APInt(8, 69)));
783 EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -10, true))
784 .addWithNoWrap(ConstantRange(APInt(8, 5), APInt(8, 20)),
786 ConstantRange(APInt(8, 125), APInt(8, 9)));
788 ConstantRange(APInt(8, 5), APInt(8, 20))
789 .addWithNoWrap(ConstantRange(APInt(8, 120), APInt(8, -10, true)),
791 ConstantRange(APInt(8, 125), APInt(8, 9)));
794 [](const ConstantRange &CR1, const ConstantRange &CR2) {
811 EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 2)),
813 ConstantRange(APInt(16, 1), APInt(16, 0)));
814 EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 2))
816 ConstantRange(APInt(16, 1), APInt(16, 0)));
817 EXPECT_EQ(ConstantRange(APInt(8, 200), APInt(8, 220))
818 .addWithNoWrap(ConstantRange(APInt(8, 100), APInt(8, 123)),
820 ConstantRange(8, false));
821 EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
822 .addWithNoWrap(ConstantRange(APInt(8, 0), APInt(8, 156)),
824 ConstantRange(8, true));
825 EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
826 .addWithNoWrap(ConstantRange(APInt(8, 10), APInt(8, 29)),
828 ConstantRange(APInt(8, 10), APInt(8, 129)));
829 EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, 10))
830 .addWithNoWrap(ConstantRange(APInt(8, 50), APInt(8, 200)),
832 ConstantRange(APInt(8, 50), APInt(8, 0)));
833 EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
834 .addWithNoWrap(ConstantRange(APInt(8, 50), APInt(8, 200)),
836 ConstantRange(APInt(8, 60), APInt(8, -37, true)));
837 EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, -30, true))
838 .addWithNoWrap(ConstantRange(APInt(8, 5), APInt(8, 20)),
840 ConstantRange(APInt(8, 25), APInt(8, -11, true)));
841 EXPECT_EQ(ConstantRange(APInt(8, 5), APInt(8, 20))
842 .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, -30, true)),
844 ConstantRange(APInt(8, 25), APInt(8, -11, true)));
847 [](const ConstantRange &CR1, const ConstantRange &CR2) {
859 EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
860 .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
862 ConstantRange(APInt(8, 70), APInt(8, -128, true)));
863 EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
864 .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
866 ConstantRange(APInt(8, 70), APInt(8, 169)));
867 EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
868 .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
870 ConstantRange(APInt(8, 70), APInt(8, -128, true)));
872 EXPECT_EQ(ConstantRange(APInt(8, -100, true), APInt(8, -50, true))
873 .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
875 ConstantRange(APInt(8, -80, true), APInt(8, -21, true)));
876 EXPECT_EQ(ConstantRange(APInt(8, -100, true), APInt(8, -50, true))
877 .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
879 ConstantRange(APInt(8, 176), APInt(8, 235)));
880 EXPECT_EQ(ConstantRange(APInt(8, -100, true), APInt(8, -50, true))
881 .addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
883 ConstantRange(APInt(8, 176), APInt(8, 235)));
886 [](const ConstantRange &CR1, const ConstantRange &CR2) {
914 ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
916 ConstantRange(APInt(16, 0xf561), APInt(16, 0xaa0)));
918 ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
920 ConstantRange(APInt(16, 0x6)));
923 [](const ConstantRange &CR1, const ConstantRange &CR2) {
934 [](const ConstantRange &CR1, const ConstantRange &CR2) {
946 [](const ConstantRange &CR1, const ConstantRange &CR2) {
958 [](const ConstantRange &CR1, const ConstantRange &CR2) {
983 EXPECT_EQ(One.multiply(One), ConstantRange(APInt(16, 0xa*0xa),
985 EXPECT_EQ(One.multiply(Some), ConstantRange(APInt(16, 0xa*0xa),
992 ConstantRange Zero(APInt(16, 0));
1001 EXPECT_EQ(ConstantRange(APInt(4, 1), APInt(4, 6)).multiply(
1002 ConstantRange(APInt(4, 6), APInt(4, 2))),
1003 ConstantRange(4, /*isFullSet=*/true));
1005 EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 0)).multiply(
1006 ConstantRange(APInt(8, 252), APInt(8, 4))),
1007 ConstantRange(APInt(8, 250), APInt(8, 9)));
1008 EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 255)).multiply(
1009 ConstantRange(APInt(8, 2), APInt(8, 4))),
1010 ConstantRange(APInt(8, 250), APInt(8, 253)));
1013 EXPECT_EQ(ConstantRange(APInt(8, -2, true))
1014 .multiply(ConstantRange(APInt(8, 0), APInt(8, 2))),
1015 ConstantRange(APInt(8, -2, true), APInt(8, 1)));
1018 EXPECT_EQ(ConstantRange(APInt(8, 3), APInt(8, -11, true))
1019 .multiply(ConstantRange(APInt(8, -1, true))),
1020 ConstantRange(APInt(8, 12), APInt(8, -2, true)));
1021 EXPECT_EQ(ConstantRange(APInt(8, -1, true))
1022 .multiply(ConstantRange(APInt(8, 3), APInt(8, -11, true))),
1023 ConstantRange(APInt(8, 12), APInt(8, -2, true)));
1026 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1033 [](const ConstantRange &, const ConstantRange &) {
1046 EXPECT_EQ(ConstantRange(APInt(4, 0), APInt(4, 2))
1047 .multiplyWithNoWrap(ConstantRange(APInt(4, 2), APInt(4, 0)),
1049 ConstantRange::getFull(4));
1050 EXPECT_EQ(ConstantRange(APInt(4, 1), APInt(4, 5))
1051 .multiplyWithNoWrap(ConstantRange(APInt(4, 1), APInt(4, 5)),
1053 ConstantRange(APInt(4, 1), APInt(4, 0)));
1054 EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 0))
1055 .multiplyWithNoWrap(ConstantRange(APInt(8, 252), APInt(8, 4)),
1057 ConstantRange(APInt(8, 250), APInt(8, 9)));
1058 EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 255))
1059 .multiplyWithNoWrap(ConstantRange(APInt(8, 2), APInt(8, 4)),
1061 ConstantRange::getEmpty(8));
1069 ConstantRange(APInt(4, 0), APInt(4, 4))
1070 .multiplyWithNoWrap(ConstantRange(APInt(4, -5, true), APInt(4, 4)),
1072 ConstantRange::getFull(4));
1073 EXPECT_EQ(ConstantRange(APInt(4, 0), APInt(4, 3))
1074 .multiplyWithNoWrap(ConstantRange(APInt(4, 0), APInt(4, 5)),
1076 ConstantRange(APInt(4, 0), APInt(4, -8, true)));
1077 EXPECT_EQ(ConstantRange(APInt(8, 3), APInt(8, -11, true))
1078 .multiplyWithNoWrap(ConstantRange(APInt(8, -1, true)),
1080 ConstantRange(APInt(8, 12), APInt(8, -2, true)));
1081 EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 255))
1082 .multiplyWithNoWrap(ConstantRange(APInt(8, 100), APInt(8, 121)),
1084 ConstantRange::getEmpty(8));
1085 EXPECT_TRUE(ConstantRange::getFull(8)
1086 .multiplyWithNoWrap(ConstantRange(APInt(8, 2), APInt(8, 128)),
1089 EXPECT_TRUE(ConstantRange(APInt(8, 2), APInt(8, 128))
1090 .multiplyWithNoWrap(ConstantRange::getFull(8),
1094 ConstantRange::getFull(8)
1095 .multiplyWithNoWrap(ConstantRange(APInt(8, 1), APInt(8, 128)),
1099 ConstantRange::getFull(8)
1100 .multiplyWithNoWrap(ConstantRange(APInt(8, 2), APInt(8, 128)),
1105 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1117 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1129 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1147 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1157 EXPECT_EQ(Full.umax(Some), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
1159 EXPECT_EQ(Full.umax(Some), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
1165 EXPECT_EQ(Some.umax(Wrap), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
1168 EXPECT_EQ(Wrap.umax(One), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
1172 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1184 EXPECT_EQ(Full.smax(Some), ConstantRange(APInt(16, 0xa),
1187 EXPECT_EQ(Full.smax(One), ConstantRange(APInt(16, 0xa),
1195 ConstantRange(APInt(16, 0xa), APInt(16, (uint16_t)INT16_MIN)));
1198 ConstantRange(APInt(16, 0xa), APInt(16, (uint16_t)INT16_MIN)));
1202 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1214 EXPECT_EQ(Full.umin(Some), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1221 EXPECT_EQ(Some.umin(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1224 EXPECT_EQ(Wrap.umin(One), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1228 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1241 ConstantRange(APInt(16, (uint16_t)INT16_MIN), APInt(16, 0xaaa)));
1249 ConstantRange(APInt(16, (uint16_t)INT16_MIN), APInt(16, 0xaaa)));
1253 ConstantRange(APInt(16, (uint16_t)INT16_MIN), APInt(16, 0xb)));
1257 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1269 EXPECT_EQ(Full.udiv(One), ConstantRange(APInt(16, 0),
1271 EXPECT_EQ(Full.udiv(Some), ConstantRange(APInt(16, 0),
1278 EXPECT_EQ(One.udiv(One), ConstantRange(APInt(16, 1)));
1279 EXPECT_EQ(One.udiv(Some), ConstantRange(APInt(16, 0), APInt(16, 2)));
1280 EXPECT_EQ(One.udiv(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1281 EXPECT_EQ(Some.udiv(Some), ConstantRange(APInt(16, 0), APInt(16, 0x111)));
1282 EXPECT_EQ(Some.udiv(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1286 ConstantRange Zero(APInt(16, 0));
1290 EXPECT_EQ(ConstantRange(APInt(16, 0), APInt(16, 99)).udiv(Full),
1291 ConstantRange(APInt(16, 0), APInt(16, 99)));
1292 EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 99)).udiv(Full),
1293 ConstantRange(APInt(16, 0), APInt(16, 99)));
1297 ConstantRange OneBit = ConstantRange::getFull(1);
1298 EXPECT_EQ(OneBit.sdiv(OneBit), ConstantRange(APInt(1, 0)));
1300 EnumerateTwoInterestingConstantRanges([&](const ConstantRange &CR1,
1301 const ConstantRange &CR2) {
1322 ConstantRange CR = CR1.sdiv(CR2);
1331 ConstantRange Envelope = ConstantRange::getNonEmpty(SMin, SMax + 1);
1351 ConstantRange Wrapped = ConstantRange::getNonEmpty(WMin, WMax + 1);
1360 EXPECT_EQ(Full.urem(ConstantRange(APInt(16, 0))), Empty);
1362 EXPECT_EQ(Full.urem(Full), ConstantRange(APInt(16, 0), APInt(16, 0xffff)));
1364 EXPECT_EQ(Full.urem(ConstantRange(APInt(16, 0), APInt(16, 123))),
1365 ConstantRange(APInt(16, 0), APInt(16, 122)));
1367 EXPECT_EQ(ConstantRange(APInt(16, 0), APInt(16, 123)).urem(Full),
1368 ConstantRange(APInt(16, 0), APInt(16, 123)));
1370 EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 20))
1371 .urem(ConstantRange(APInt(16, 20), APInt(16, 30))),
1372 ConstantRange(APInt(16, 10), APInt(16, 20)));
1374 EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 20))
1375 .urem(ConstantRange(APInt(16, 19), APInt(16, 30))),
1376 ConstantRange(APInt(16, 0), APInt(16, 20)));
1378 EXPECT_EQ(ConstantRange(APInt(16, 12), APInt(16, 15))
1379 .urem(ConstantRange(APInt(16, 10))),
1380 ConstantRange(APInt(16, 0), APInt(16, 10)));
1383 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1398 EXPECT_EQ(Full.srem(ConstantRange(APInt(16, 0))), Empty);
1400 EXPECT_EQ(Full.srem(Full), ConstantRange(APInt::getSignedMinValue(16) + 1,
1403 ConstantRange PosMod(APInt(16, 10), APInt(16, 21)); // [10, 20]
1404 ConstantRange NegMod(APInt(16, -20, true), APInt(16, -9, true)); // [-20, -10]
1405 ConstantRange IntMinMod(APInt::getSignedMinValue(16));
1407 ConstantRange Expected(16, true);
1410 ConstantRange PosLargeLHS(APInt(16, 0), APInt(16, 41));
1411 Expected = ConstantRange(APInt(16, 0), APInt(16, 20));
1414 ConstantRange NegLargeLHS(APInt(16, -40, true), APInt(16, 1));
1415 Expected = ConstantRange(APInt(16, -19, true), APInt(16, 1));
1418 ConstantRange PosNegLargeLHS(APInt(16, -32, true), APInt(16, 38));
1419 Expected = ConstantRange(APInt(16, -19, true), APInt(16, 20));
1424 ConstantRange PosLHS(APInt(16, 0), APInt(16, 16));
1428 ConstantRange NegLHS(APInt(16, -15, true), APInt(16, 1));
1432 ConstantRange PosNegLHS(APInt(16, -12, true), APInt(16, 18));
1438 ConstantRange PosSmallLHS(APInt(16, 3), APInt(16, 8));
1442 ConstantRange NegSmallLHS(APInt(16, -7, true), APInt(16, -2, true));
1446 ConstantRange PosNegSmallLHS(APInt(16, -3, true), APInt(16, 8));
1453 EXPECT_EQ(ConstantRange(APInt(16, 12), APInt(16, 15))
1454 .srem(ConstantRange(APInt(16, 10))),
1455 ConstantRange(APInt(16, 0), APInt(16, 10)));
1458 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1470 ConstantRange Some2(APInt(16, 0xfff), APInt(16, 0x8000));
1471 ConstantRange WrapNullMax(APInt(16, 0x1), APInt(16, 0x0));
1474 EXPECT_EQ(Full.shl(One), ConstantRange(APInt(16, 0),
1482 EXPECT_EQ(One.shl(One), ConstantRange(APInt(16, 0xa << 0xa),
1490 Some2.shl(ConstantRange(APInt(16, 0x1))),
1491 ConstantRange(APInt(16, 0xfff << 0x1), APInt(16, 0x7fff << 0x1) + 1));
1494 ConstantRange NegOne(APInt(16, 0xffff));
1495 EXPECT_EQ(NegOne.shl(ConstantRange(APInt(16, 0), APInt(16, 5))),
1496 ConstantRange(APInt(16, 0xfff0), APInt(16, 0)));
1497 EXPECT_EQ(ConstantRange(APInt(16, 0xfffe), APInt(16, 0))
1498 .shl(ConstantRange(APInt(16, 0), APInt(16, 5))),
1499 ConstantRange(APInt(16, 0xffe0), APInt(16, 0)));
1502 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1511 [](const ConstantRange &, const ConstantRange &CR2) {
1520 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1521 ConstantRange Res = CR1.shlWithNoWrap(CR2, OBO::NoUnsignedWrap);
1534 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1546 [](const ConstantRange &CR1, const ConstantRange &CR2) {
1561 ConstantRange(APInt(16, 10), APInt(16, 20481)));
1563 ConstantRange(APInt(16, 10), APInt(16, -24575, true)));
1565 ConstantRange(APInt(16, 10), APInt(16, 20481)));
1566 ConstantRange NegOne(APInt(16, 0xffff));
1568 ConstantRange(APInt(16, -32768, true), APInt(16, 0)));
1570 EXPECT_EQ(ConstantRange(APInt(16, 768))
1572 ConstantRange(APInt(16, 768), APInt(16, 24577)));
1573 EXPECT_EQ(Full.shlWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 16)),
1575 ConstantRange(APInt(16, 0), APInt(16, -1, true)));
1576 EXPECT_EQ(ConstantRange(APInt(4, 3), APInt(4, -8, true))
1577 .shlWithNoWrap(ConstantRange(APInt(4, 0), APInt(4, 4)),
1579 ConstantRange(APInt(4, 3), APInt(4, -8, true)));
1580 EXPECT_EQ(ConstantRange(APInt(4, -1, true), APInt(4, 0))
1581 .shlWithNoWrap(ConstantRange(APInt(4, 1), APInt(4, 4)),
1583 ConstantRange(APInt(4, -8, true), APInt(4, -1, true)));
1589 EXPECT_EQ(Full.lshr(One), ConstantRange(APInt(16, 0),
1591 EXPECT_EQ(Full.lshr(Some), ConstantRange(APInt(16, 0),
1598 EXPECT_EQ(One.lshr(One), ConstantRange(APInt(16, 0)));
1599 EXPECT_EQ(One.lshr(Some), ConstantRange(APInt(16, 0)));
1600 EXPECT_EQ(One.lshr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1601 EXPECT_EQ(Some.lshr(Some), ConstantRange(APInt(16, 0),
1603 EXPECT_EQ(Some.lshr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1610 EXPECT_EQ(Full.ashr(One), ConstantRange(APInt(16, 0xffe0),
1612 ConstantRange Small(APInt(16, 0xa), APInt(16, 0xb));
1613 EXPECT_EQ(Full.ashr(Small), ConstantRange(APInt(16, 0xffe0),
1615 EXPECT_EQ(Full.ashr(Some), ConstantRange(APInt(16, 0xffe0),
1622 EXPECT_EQ(One.ashr(One), ConstantRange(APInt(16, 0)));
1623 EXPECT_EQ(One.ashr(Some), ConstantRange(APInt(16, 0)));
1624 EXPECT_EQ(One.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
1625 EXPECT_EQ(Some.ashr(Some), ConstantRange(APInt(16, 0),
1627 EXPECT_EQ(Some.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
1629 ConstantRange Neg(APInt(16, 0xf3f0), APInt(16, 0xf7f8));
1631 ConstantRange(APInt(16, 0xfffc), APInt(16, 0xfffe)));
1634 TEST(ConstantRange, MakeAllowedICmpRegion) {
1636 ConstantRange SMax = ConstantRange(APInt::getSignedMaxValue(32));
1637 EXPECT_TRUE(ConstantRange::makeAllowedICmpRegion(ICmpInst::ICMP_SGT, SMax)
1641 TEST(ConstantRange, MakeSatisfyingICmpRegion) {
1642 ConstantRange LowHalf(APInt(8, 0), APInt(8, 128));
1643 ConstantRange HighHalf(APInt(8, 128), APInt(8, 0));
1644 ConstantRange EmptySet(8, /* isFullSet = */ false);
1646 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_NE, LowHalf),
1650 ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_NE, HighHalf),
1653 EXPECT_TRUE(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_EQ,
1656 ConstantRange UnsignedSample(APInt(8, 5), APInt(8, 200));
1658 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULT,
1660 ConstantRange(APInt(8, 0), APInt(8, 5)));
1662 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULE,
1664 ConstantRange(APInt(8, 0), APInt(8, 6)));
1666 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGT,
1668 ConstantRange(APInt(8, 200), APInt(8, 0)));
1670 EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGE,
1672 ConstantRange(APInt(8, 199), APInt(8, 0)));
1674 ConstantRange SignedSample(APInt(8, -5, true), APInt(8, 5));
1677 ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLT, SignedSample),
1678 ConstantRange(APInt(8, -128, true), APInt(8, -5, true)));
1681 ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLE, SignedSample),
1682 ConstantRange(APInt(8, -128, true), APInt(8, -4, true)));
1685 ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGT, SignedSample),
1686 ConstantRange(APInt(8, 5), APInt(8, -128, true)));
1689 ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGE, SignedSample),
1690 ConstantRange(APInt(8, 4), APInt(8, -128, true)));
1695 [&](const ConstantRange &CR1, const ConstantRange &CR2) {
1706 TEST(ConstantRange, ICmp) {
1711 TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
1719 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1724 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1747 auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1752 auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
1772 auto NSWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1773 Instruction::Add, ConstantRange(32, /* isFullSet = */ true),
1778 NSWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1779 Instruction::Sub, ConstantRange(32, /* isFullSet = */ true),
1784 auto NUWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1785 Instruction::Add, ConstantRange(32, /* isFullSet = */ true),
1790 NUWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
1791 Instruction::Sub, ConstantRange(32, /* isFullSet = */ true),
1796 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1798 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1800 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1802 EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
1805 ConstantRange OneToFive(APInt(32, 1), APInt(32, 6));
1806 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1808 ConstantRange(APInt::getSignedMinValue(32),
1810 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1812 ConstantRange(APInt::getMinValue(32), APInt::getMinValue(32) - 5));
1813 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1815 ConstantRange(APInt::getSignedMinValue(32) + 5,
1817 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1819 ConstantRange(APInt::getMinValue(32) + 5, APInt::getMinValue(32)));
1821 ConstantRange MinusFiveToMinusTwo(APInt(32, -5, true), APInt(32, -1, true));
1822 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1824 ConstantRange(APInt::getSignedMinValue(32) + 5,
1826 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1828 ConstantRange(APInt(32, 0), APInt(32, 2)));
1829 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1831 ConstantRange(APInt::getSignedMinValue(32),
1833 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1835 ConstantRange(APInt::getMaxValue(32) - 1, APInt::getMinValue(32)));
1837 ConstantRange MinusOneToOne(APInt(32, -1, true), APInt(32, 2));
1838 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1840 ConstantRange(APInt::getSignedMinValue(32) + 1,
1842 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1844 ConstantRange(APInt(32, 0), APInt(32, 1)));
1845 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1847 ConstantRange(APInt::getSignedMinValue(32) + 1,
1849 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1851 ConstantRange(APInt::getMaxValue(32),
1854 ConstantRange One(APInt(32, 1), APInt(32, 2));
1855 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1857 ConstantRange(APInt::getSignedMinValue(32),
1859 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1861 ConstantRange(APInt::getMinValue(32), APInt::getMaxValue(32)));
1862 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1864 ConstantRange(APInt::getSignedMinValue(32) + 1,
1866 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1868 ConstantRange(APInt::getMinValue(32) + 1, APInt::getMinValue(32)));
1870 ConstantRange OneLessThanBitWidth(APInt(32, 0), APInt(32, 31) + 1);
1871 ConstantRange UpToBitWidth(APInt(32, 0), APInt(32, 32) + 1);
1872 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1874 ConstantRange::makeGuaranteedNoWrapRegion(
1876 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1878 ConstantRange::makeGuaranteedNoWrapRegion(
1880 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1882 ConstantRange(APInt(32, 0), APInt(32, 1) + 1));
1883 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1885 ConstantRange(APInt(32, -1, true), APInt(32, 0) + 1));
1888 ConstantRange::makeGuaranteedNoWrapRegion(
1889 Instruction::Shl, ConstantRange::getFull(32), OBO::NoUnsignedWrap),
1890 ConstantRange::makeGuaranteedNoWrapRegion(
1893 ConstantRange::makeGuaranteedNoWrapRegion(
1894 Instruction::Shl, ConstantRange::getFull(32), OBO::NoSignedWrap),
1895 ConstantRange::makeGuaranteedNoWrapRegion(
1898 ConstantRange IllegalShAmt(APInt(32, 32), APInt(32, 0) + 1);
1899 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1901 ConstantRange::getFull(32));
1902 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1904 ConstantRange::getFull(32));
1906 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1908 ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
1910 ConstantRange::makeGuaranteedNoWrapRegion(
1912 ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
1914 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1916 ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
1918 ConstantRange::makeGuaranteedNoWrapRegion(
1920 ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
1923 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1925 ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
1927 ConstantRange(APInt(32, 0), APInt(32, 65535) + 1));
1928 EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
1930 ConstantRange(APInt(32, -32, true), APInt(32, 16) + 1),
1932 ConstantRange(APInt(32, -32768, true), APInt(32, 32767) + 1));
1939 EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
1945 ConstantRange NoWrap =
1946 ConstantRange::makeGuaranteedNoWrapRegion(BinOp, CR, NoWrapKind);
1969 TEST(ConstantRange, NoWrapRegionExhaustive) {
2028 TEST(ConstantRange, GetEquivalentICmp) {
2032 EXPECT_TRUE(ConstantRange(APInt::getMinValue(32), APInt(32, 100))
2037 EXPECT_TRUE(ConstantRange(APInt::getSignedMinValue(32), APInt(32, 100))
2042 EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getMinValue(32))
2047 EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getSignedMinValue(32))
2053 ConstantRange(32, /*isFullSet=*/true).getEquivalentICmp(Pred, RHS));
2058 ConstantRange(32, /*isFullSet=*/false).getEquivalentICmp(Pred, RHS));
2062 EXPECT_FALSE(ConstantRange(APInt(32, 100), APInt(32, 200))
2065 EXPECT_FALSE(ConstantRange(APInt::getSignedMinValue(32) - APInt(32, 100),
2069 EXPECT_FALSE(ConstantRange(APInt::getMinValue(32) - APInt(32, 100),
2073 EXPECT_TRUE(ConstantRange(APInt(32, 100)).getEquivalentICmp(Pred, RHS));
2078 ConstantRange(APInt(32, 100)).inverse().getEquivalentICmp(Pred, RHS));
2083 ConstantRange(APInt(512, 100)).inverse().getEquivalentICmp(Pred, RHS));
2091 EXPECT_TRUE(ConstantRange(APInt(32, 0)).getEquivalentICmp(Pred, RHS));
2096 ConstantRange(APInt(32, 0)).inverse().getEquivalentICmp(Pred, RHS));
2100 EXPECT_TRUE(ConstantRange(APInt(32, -1, true)).getEquivalentICmp(Pred, RHS));
2104 EXPECT_TRUE(ConstantRange(APInt(32, -1, true))
2110 EnumerateInterestingConstantRanges([](const ConstantRange &CR) {
2130 EXPECT_EQ(ConstantRange::OverflowResult::MayOverflow, (op))
2132 EXPECT_EQ(ConstantRange::OverflowResult::AlwaysOverflowsLow, (op))
2134 EXPECT_EQ(ConstantRange::OverflowResult::AlwaysOverflowsHigh, (op))
2136 EXPECT_EQ(ConstantRange::OverflowResult::NeverOverflows, (op))
2144 ConstantRange Zero(APInt::getZero(16));
2156 ConstantRange A(APInt(16, 0xfd00), APInt(16, 0xfe00));
2157 ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
2158 ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
2164 ConstantRange C1(APInt(16, 0x0299), APInt(16, 0x0400));
2165 ConstantRange C2(APInt(16, 0x0300), APInt(16, 0x0400));
2178 ConstantRange Zero(APInt::getZero(16));
2179 ConstantRange Max(APInt::getAllOnes(16));
2191 ConstantRange A(APInt(16, 0x0000), APInt(16, 0x0100));
2192 ConstantRange B(APInt(16, 0x0100), APInt(16, 0x0200));
2196 ConstantRange A1(APInt(16, 0x0000), APInt(16, 0x0101));
2197 ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
2201 ConstantRange A2(APInt(16, 0x0000), APInt(16, 0x0102));
2202 ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
2213 ConstantRange Zero(APInt::getZero(16));
2225 ConstantRange A(APInt(16, 0x7d00), APInt(16, 0x7e00));
2226 ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
2227 ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
2230 ConstantRange B3(APInt(16, 0x8000), APInt(16, 0x0201));
2231 ConstantRange B4(APInt(16, 0x8000), APInt(16, 0x0202));
2234 ConstantRange B5(APInt(16, 0x0299), APInt(16, 0x0400));
2235 ConstantRange B6(APInt(16, 0x0300), APInt(16, 0x0400));
2239 ConstantRange C(APInt(16, 0x8200), APInt(16, 0x8300));
2240 ConstantRange D1(APInt(16, 0xfe00), APInt(16, 0xff00));
2241 ConstantRange D2(APInt(16, 0xfd99), APInt(16, 0xff00));
2244 ConstantRange D3(APInt(16, 0xfe00), APInt(16, 0x8000));
2245 ConstantRange D4(APInt(16, 0xfd99), APInt(16, 0x8000));
2248 ConstantRange D5(APInt(16, 0xfc00), APInt(16, 0xfd02));
2249 ConstantRange D6(APInt(16, 0xfc00), APInt(16, 0xfd01));
2253 ConstantRange E(APInt(16, 0xff00), APInt(16, 0x0100));
2255 ConstantRange F(APInt(16, 0xf000), APInt(16, 0x7000));
2265 ConstantRange Zero(APInt::getZero(16));
2275 ConstantRange A(APInt(16, 0x7d00), APInt(16, 0x7e00));
2276 ConstantRange B1(APInt(16, 0xfe00), APInt(16, 0xff00));
2277 ConstantRange B2(APInt(16, 0xfd99), APInt(16, 0xff00));
2280 ConstantRange B3(APInt(16, 0xfc00), APInt(16, 0xfd02));
2281 ConstantRange B4(APInt(16, 0xfc00), APInt(16, 0xfd01));
2285 ConstantRange C(APInt(16, 0x8200), APInt(16, 0x8300));
2286 ConstantRange D1(APInt(16, 0x0100), APInt(16, 0x0201));
2287 ConstantRange D2(APInt(16, 0x0100), APInt(16, 0x0202));
2290 ConstantRange D3(APInt(16, 0x0299), APInt(16, 0x0400));
2291 ConstantRange D4(APInt(16, 0x0300), APInt(16, 0x0400));
2295 ConstantRange E(APInt(16, 0xff00), APInt(16, 0x0100));
2297 ConstantRange F(APInt(16, 0xf000), APInt(16, 0x7001));
2304 EnumerateTwoInterestingConstantRanges([=](const ConstantRange &CR1,
2305 const ConstantRange &CR2) {
2326 ConstantRange::OverflowResult OR = MayOverflowFn(CR1, CR2);
2328 case ConstantRange::OverflowResult::AlwaysOverflowsLow:
2333 case ConstantRange::OverflowResult::AlwaysOverflowsHigh:
2338 case ConstantRange::OverflowResult::NeverOverflows:
2343 case ConstantRange::OverflowResult::MayOverflow:
2365 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2378 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2391 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2404 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2417 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2424 EXPECT_EQ(Full, ConstantRange::fromKnownBits(Unknown, /*signed*/false));
2425 EXPECT_EQ(Full, ConstantRange::fromKnownBits(Unknown, /*signed*/true));
2432 ConstantRange Unsigned(APInt(8, 66), APInt(8, 219 + 1));
2433 ConstantRange Signed(APInt(8, 194), APInt(8, 91 + 1));
2434 EXPECT_EQ(Unsigned, ConstantRange::fromKnownBits(Known, /*signed*/false));
2435 EXPECT_EQ(Signed, ConstantRange::fromKnownBits(Known, /*signed*/true));
2440 ConstantRange CR1(APInt(8, 164), APInt(8, 237 + 1));
2441 EXPECT_EQ(CR1, ConstantRange::fromKnownBits(Known, /*signed*/false));
2442 EXPECT_EQ(CR1, ConstantRange::fromKnownBits(Known, /*signed*/true));
2447 ConstantRange CR2(APInt(8, 68), APInt(8, 110 + 1));
2448 EXPECT_EQ(CR2, ConstantRange::fromKnownBits(Known, /*signed*/false));
2449 EXPECT_EQ(CR2, ConstantRange::fromKnownBits(Known, /*signed*/true));
2471 TestRange(ConstantRange::fromKnownBits(Known, false),
2473 TestRange(ConstantRange::fromKnownBits(Known, true),
2480 EnumerateInterestingConstantRanges([&](const ConstantRange &CR) {
2507 EnumerateInterestingConstantRanges([](const ConstantRange &CR) {
2532 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2543 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2554 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2563 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2572 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2583 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2594 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2603 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2612 [](const ConstantRange &CR) { return CR.abs(); },
2616 [](const ConstantRange &CR) { return CR.abs(/*IntMinIsPoison=*/true); },
2626 [](const ConstantRange &CR) { return CR.ctlz(); },
2630 [](const ConstantRange &CR) { return CR.ctlz(/*ZeroIsPoison=*/true); },
2640 [](const ConstantRange &CR) { return CR.cttz(); },
2644 [](const ConstantRange &CR) { return CR.cttz(/*ZeroIsPoison=*/true); },
2654 [](const ConstantRange &CR) { return CR.ctpop(); },
2659 ConstantRange A(APInt(16, 66), APInt(16, 128));
2660 ConstantRange FpToI8 = A.castOp(Instruction::FPToSI, 8);
2664 ConstantRange FpToI16 = A.castOp(Instruction::FPToSI, 16);
2668 ConstantRange FPExtToDouble = A.castOp(Instruction::FPExt, 64);
2672 ConstantRange PtrToInt = A.castOp(Instruction::PtrToInt, 64);
2676 ConstantRange IntToPtr = A.castOp(Instruction::IntToPtr, 64);
2680 ConstantRange UIToFP = A.castOp(Instruction::UIToFP, 16);
2684 ConstantRange UIToFP2 = A.castOp(Instruction::UIToFP, 64);
2685 ConstantRange B(APInt(64, 0), APInt(64, 65536));
2689 ConstantRange SIToFP = A.castOp(Instruction::SIToFP, 16);
2693 ConstantRange SIToFP2 = A.castOp(Instruction::SIToFP, 64);
2694 ConstantRange C(APInt(64, -32768), APInt(64, 32768));
2701 ConstantRange R16(APInt(8, 16));
2702 ConstantRange R20(APInt(8, 20));
2706 ConstantRange R16_32(APInt(8, 16), APInt(8, 32));
2708 ConstantRange R32(APInt(8, 32));
2712 ConstantRange R4(APInt(8, 4));
2713 ConstantRange R0_5(APInt(8, 0), APInt(8, 5));
2718 ConstantRange R0_99(APInt(8, 0), APInt(8, 99));
2719 ConstantRange R0_32(APInt(8, 0), APInt(8, 32));
2724 ConstantRange RMaskedL(APInt(8, 0b10'00101'1), APInt(8, 0b10'10000'0 + 1));
2725 ConstantRange RMaskedR(APInt(8, 0b10'11111'0), APInt(8, 0b10'11111'1 + 1));
2729 ConstantRange RMaskedL1(APInt(8, 0b00'011'010), APInt(8, 0b00'100'100 + 1));
2730 ConstantRange RMaskedR1(APInt(8, 0b00'111'010), APInt(8, 0b00'111'110 + 1));
2734 ConstantRange RMaskedL2(APInt(8, 0b0000'0111u), APInt(8, 0b0000'1101u + 1u));
2735 ConstantRange RMaskedR2(APInt(8, 0xff), APInt(8, 0));
2739 ConstantRange RMaskedL3(APInt(4, 0b0011u), APInt(4, 0));
2740 ConstantRange RMaskedR3(APInt(4, 0b1011u), APInt(4, 0));
2747 ConstantRange RMaskedL4(NegSeven, APInt(4, 1));
2748 ConstantRange RMaskedR4(NegSeven, APInt(4, 0));
2755 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2764 ConstantRange R16(APInt(8, 16));
2765 ConstantRange R20(APInt(8, 20));
2769 ConstantRange R16_32(APInt(8, 16), APInt(8, 32));
2773 ConstantRange R32(APInt(8, 32));
2774 ConstantRange R48_64(APInt(8, 48), APInt(8, 64));
2778 ConstantRange R4(APInt(8, 4));
2779 ConstantRange R0_16(APInt(8, 0), APInt(8, 16));
2780 ConstantRange R4_16(APInt(8, 4), APInt(8, 16));
2786 ConstantRange R0_64(APInt(8, 0), APInt(8, 64));
2787 ConstantRange R5_32(APInt(8, 5), APInt(8, 32));
2788 ConstantRange R5_64(APInt(8, 5), APInt(8, 64));
2793 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2802 ConstantRange R16(APInt(8, 16));
2803 ConstantRange R20(APInt(8, 20));
2808 ConstantRange R16_35(APInt(8, 16), APInt(8, 35));
2809 ConstantRange R0_99(APInt(8, 0), APInt(8, 99));
2810 EXPECT_EQ(R16_35.binaryXor(R16_35), ConstantRange(APInt(8, 0), APInt(8, 64)));
2811 EXPECT_EQ(R16_35.binaryXor(R0_99), ConstantRange(APInt(8, 0), APInt(8, 128)));
2812 EXPECT_EQ(R0_99.binaryXor(R16_35), ConstantRange(APInt(8, 0), APInt(8, 128)));
2815 ConstantRange R0_51(APInt(8, 0), APInt(8, 51));
2816 ConstantRange R63(APInt(8, 63));
2817 EXPECT_EQ(R0_51.binaryXor(R63), ConstantRange(APInt(8, 13), APInt(8, 64)));
2818 EXPECT_EQ(R63.binaryXor(R0_51), ConstantRange(APInt(8, 13), APInt(8, 64)));
2821 [](const ConstantRange &CR1, const ConstantRange &CR2) {
2833 [](const ConstantRange &CR) { return CR.binaryNot(); },
2837 [](const ConstantRange &CR) {
2838 return CR.binaryXor(ConstantRange(APInt::getAllOnes(CR.getBitWidth())));
2842 [](const ConstantRange &CR) {
2843 return ConstantRange(APInt::getAllOnes(CR.getBitWidth())).binaryXor(CR);
2851 [&](const ConstantRange &CR1, const ConstantRange &CR2) {
2879 const ConstantRange &CR1,
2880 const ConstantRange &CR2) {
2883 ConstantRange::areInsensitiveToSignednessOfICmpPredicate(CR1, CR2));
2896 Pred, [InvertedFlippedSignednessPred](const ConstantRange &CR1,
2897 const ConstantRange &CR2) {
2900 ConstantRange::areInsensitiveToSignednessOfInvertedICmpPredicate(
2911 Pred, [Pred](const ConstantRange &CR1, const ConstantRange &CR2) {
2913 ConstantRange::getEquivalentPredWithFlippedSignedness(Pred, CR1,
2933 ConstantRange CR(APInt(4, 2), APInt(4, 1));
2934 EXPECT_EQ(CR, ConstantRange::makeMaskNotEqualRange(APInt(4, 1), APInt(4, 1)));
2935 EXPECT_NE(CR, ConstantRange::makeMaskNotEqualRange(APInt(4, 0),
2941 ConstantRange CR2(APInt(4, -8, true), APInt(4, 4));
2942 auto MMNE = ConstantRange::makeMaskNotEqualRange(APInt(4, 4), APInt(4, 4));
2944 EXPECT_NE(ConstantRange::getNonEmpty(APInt(4, 0), APInt(4, -4, true)), MMNE);
2947 ConstantRange CR3(APInt(8, 240), APInt(8, 248));
2949 ConstantRange::makeMaskNotEqualRange(APInt(8, 248), APInt(8, 240)));
2952 EXPECT_EQ(ConstantRange::getFull(4),
2953 ConstantRange::makeMaskNotEqualRange(APInt(4, 0), APInt(4, 15)));
2973 TestRange(ConstantRange::makeMaskNotEqualRange(Mask, C), Elems,