[KnownBits] Add operator==

[nikic]

Summary

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 the eq() method implements, which returns Optional<bool>).

[craig.topper]

This makes sense to me. LGTM

llvm/include/llvm/Support/KnownBits.h

public:
   KnownBits byteSwap() {
     return KnownBits(Zero.byteSwap(), One.byteSwap());
   }
 
   KnownBits reverseBits() {
     return KnownBits(Zero.reverseBits(), One.reverseBits());
   }
 
+  bool operator==(const KnownBits &Other) const {
+    return Zero == Other.Zero && One == Other.One;
+  }
+
+  bool operator!=(const KnownBits &Other) const { return !(*this == Other); }
+
   void print(raw_ostream &OS) const;
   void dump() const;
 };
 
 inline KnownBits operator&(KnownBits LHS, const KnownBits &RHS) {
   LHS &= RHS;
   return LHS;
 }

llvm/lib/Support/KnownBits.cpp

KnownBits KnownBits::abs(bool IntMinIsPoison) const {
   return KnownAbs;
 }
 
 KnownBits KnownBits::mul(const KnownBits &LHS, const KnownBits &RHS,
                          bool NoUndefSelfMultiply) {
   unsigned BitWidth = LHS.getBitWidth();
   assert(BitWidth == RHS.getBitWidth() && !LHS.hasConflict() &&
          !RHS.hasConflict() && "Operand mismatch");
-  assert(
-      (!NoUndefSelfMultiply || (LHS.One == RHS.One && LHS.Zero == RHS.Zero)) &&
+  assert((!NoUndefSelfMultiply || LHS == RHS) &&
          "Self multiplication knownbits mismatch");
 
   // Compute the high known-0 bits by multiplying the unsigned max of each side.
   // Conservatively, M active bits * N active bits results in M + N bits in the
   // result. But if we know a value is a power-of-2 for example, then this
   // computes one more leading zero.
   // TODO: This could be generalized to number of sign bits (negative numbers).
   APInt UMaxLHS = LHS.getMaxValue();
   APInt UMaxRHS = RHS.getMaxValue();

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

if (Cmp->isEquality() && Zext.getType() == Cmp->getOperand(0)->getType()) {
     // that may lead to additional simplifications.
     if (IntegerType *ITy = dyn_cast<IntegerType>(Zext.getType())) {
       Value *LHS = Cmp->getOperand(0);
       Value *RHS = Cmp->getOperand(1);
 
       KnownBits KnownLHS = computeKnownBits(LHS, 0, &Zext);
       KnownBits KnownRHS = computeKnownBits(RHS, 0, &Zext);
 
-      if (KnownLHS.Zero == KnownRHS.Zero && KnownLHS.One == KnownRHS.One) {
+      if (KnownLHS == KnownRHS) {
         APInt KnownBits = KnownLHS.Zero | KnownLHS.One;
         APInt UnknownBit = ~KnownBits;
         if (UnknownBit.countPopulation() == 1) {
           Value *Result = Builder.CreateXor(LHS, RHS);
 
           // Mask off any bits that are set and won't be shifted away.
           if (KnownLHS.One.uge(UnknownBit))
             Result = Builder.CreateAnd(Result,

llvm/unittests/IR/ConstantRangeTest.cpp

EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
     ExpectedKnown.Zero.setAllBits();
     ExpectedKnown.One.setAllBits();
     ForeachNumInConstantRange(CR, [&](const APInt &N) {
       ExpectedKnown.One &= N;
       ExpectedKnown.Zero &= ~N;
     });
     // For an empty CR any result would be legal.
     if (!CR.isEmptySet()) {
-      EXPECT_EQ(ExpectedKnown.One, Known.One);
-      EXPECT_EQ(ExpectedKnown.Zero, Known.Zero);
+      EXPECT_EQ(ExpectedKnown, Known);
     }
   });
 }
 
 TEST_F(ConstantRangeTest, Negative) {
   // All elements in an empty set (of which there are none) are both negative
   // and non-negative. Empty & full sets checked explicitly for clarity, but
   // they are also covered by the exhaustive test below.

llvm/unittests/Support/KnownBitsTest.cpp

ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
                 ++Add;
 
               Known.One &= Add;
               Known.Zero &= ~Add;
             });
           });
         });
 
-        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);
       });
     });
   });
 }
 
 static void TestAddSubExhaustive(bool IsAdd) {
   unsigned Bits = 4;
   ForeachKnownBits(Bits, [&](const KnownBits &Known1) {
ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
 
           if (!Overflow) {
             KnownNSW.One &= Res;
             KnownNSW.Zero &= ~Res;
           }
         });
       });
 
-      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.
       KnownBits KnownNSWComputed = KnownBits::computeForAddSub(
           IsAdd, /*NSW*/true, Known1, Known2);
       EXPECT_TRUE(KnownNSWComputed.Zero.isSubsetOf(KnownNSW.Zero));
       EXPECT_TRUE(KnownNSWComputed.One.isSubsetOf(KnownNSW.One));
     });
ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
             KnownShl.resetAll();
             KnownLShr.resetAll();
             KnownAShr.resetAll();
           }
         });
       });
 
       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.
       KnownBits ComputedMul = KnownBits::mul(Known1, Known2);
       EXPECT_TRUE(ComputedMul.Zero.isSubsetOf(KnownMul.Zero));
       EXPECT_TRUE(ComputedMul.One.isSubsetOf(KnownMul.One));
 
       KnownBits ComputedMulHS = KnownBits::mulhs(Known1, Known2);
for (unsigned Size : {NarrowerSize, BaseSize, WiderSize}) {
     for (const APInt &Input :
          {NegativeFitsNarrower, NegativeDoesntFitNarrower, PositiveFitsNarrower,
           PositiveDoesntFitNarrower}) {
       KnownBits Test;
       InitKnownBits(Test, Input);
       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);
     }
   }
 }
 
 TEST(KnownBitsTest, SExtInReg) {
   unsigned Bits = 4;
   for (unsigned FromBits = 1; FromBits <= Bits; ++FromBits) {
     ForeachKnownBits(Bits, [&](const KnownBits &Known) {