[KnownBits] Add operator==

Checking whether two KnownBits are the same is somewhat common,
mainly in test code.

I don't think there is a lot of room for confusion with "determine
what the KnownBits for an icmp eq would be", as that has a
different result type (this is what the eq() method implements,
which returns Optional<bool>).

Differential Revision: https://reviews.llvm.org/D125692

1 files changed, 14 insertions, 24 deletions

diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp
index c8d27b9..9ef62bb 100644
--- a/llvm/unittests/Support/KnownBitsTest.cpp
+++ b/llvm/unittests/Support/KnownBitsTest.cpp
@@ -41,10 +41,9 @@ TEST(KnownBitsTest, AddCarryExhaustive) {
           });
         });
 
-        KnownBits KnownComputed = KnownBits::computeForAddCarry(
-            Known1, Known2, KnownCarry);
-        EXPECT_EQ(Known.Zero, KnownComputed.Zero);
-        EXPECT_EQ(Known.One, KnownComputed.One);
+        KnownBits KnownComputed =
+            KnownBits::computeForAddCarry(Known1, Known2, KnownCarry);
+        EXPECT_EQ(Known, KnownComputed);
       });
     });
   });
@@ -79,10 +78,9 @@ static void TestAddSubExhaustive(bool IsAdd) {
         });
       });
 
-      KnownBits KnownComputed = KnownBits::computeForAddSub(
-          IsAdd, /*NSW*/false, Known1, Known2);
-      EXPECT_EQ(Known.Zero, KnownComputed.Zero);
-      EXPECT_EQ(Known.One, KnownComputed.One);
+      KnownBits KnownComputed =
+          KnownBits::computeForAddSub(IsAdd, /*NSW*/ false, Known1, Known2);
+      EXPECT_EQ(Known, KnownComputed);
 
       // The NSW calculation is not precise, only check that it's
       // conservatively correct.
@@ -201,32 +199,25 @@ TEST(KnownBitsTest, BinaryExhaustive) {
       });
 
       KnownBits ComputedAnd = Known1 & Known2;
-      EXPECT_EQ(KnownAnd.Zero, ComputedAnd.Zero);
-      EXPECT_EQ(KnownAnd.One, ComputedAnd.One);
+      EXPECT_EQ(KnownAnd, ComputedAnd);
 
       KnownBits ComputedOr = Known1 | Known2;
-      EXPECT_EQ(KnownOr.Zero, ComputedOr.Zero);
-      EXPECT_EQ(KnownOr.One, ComputedOr.One);
+      EXPECT_EQ(KnownOr, ComputedOr);
 
       KnownBits ComputedXor = Known1 ^ Known2;
-      EXPECT_EQ(KnownXor.Zero, ComputedXor.Zero);
-      EXPECT_EQ(KnownXor.One, ComputedXor.One);
+      EXPECT_EQ(KnownXor, ComputedXor);
 
       KnownBits ComputedUMax = KnownBits::umax(Known1, Known2);
-      EXPECT_EQ(KnownUMax.Zero, ComputedUMax.Zero);
-      EXPECT_EQ(KnownUMax.One, ComputedUMax.One);
+      EXPECT_EQ(KnownUMax, ComputedUMax);
 
       KnownBits ComputedUMin = KnownBits::umin(Known1, Known2);
-      EXPECT_EQ(KnownUMin.Zero, ComputedUMin.Zero);
-      EXPECT_EQ(KnownUMin.One, ComputedUMin.One);
+      EXPECT_EQ(KnownUMin, ComputedUMin);
 
       KnownBits ComputedSMax = KnownBits::smax(Known1, Known2);
-      EXPECT_EQ(KnownSMax.Zero, ComputedSMax.Zero);
-      EXPECT_EQ(KnownSMax.One, ComputedSMax.One);
+      EXPECT_EQ(KnownSMax, ComputedSMax);
 
       KnownBits ComputedSMin = KnownBits::smin(Known1, Known2);
-      EXPECT_EQ(KnownSMin.Zero, ComputedSMin.Zero);
-      EXPECT_EQ(KnownSMin.One, ComputedSMin.One);
+      EXPECT_EQ(KnownSMin, ComputedSMin);
 
       // The following are conservatively correct, but not guaranteed to be
       // precise.
@@ -476,8 +467,7 @@ TEST(KnownBitsTest, SExtOrTrunc) {
       KnownBits Baseline;
       InitKnownBits(Baseline, Input.sextOrTrunc(Size));
       Test = Test.sextOrTrunc(Size);
-      EXPECT_EQ(Test.One, Baseline.One);
-      EXPECT_EQ(Test.Zero, Baseline.Zero);
+      EXPECT_EQ(Test, Baseline);
     }
   }
 }