[InstCombine] Modify all folds of `(and/or (cmp0), (cmp1))` to not quite a completed instruction; NFC

[goldstein.w.n]

Summary

In some cases it is desirable to see if a given instruction will fold,
and only if it will, create the intermediates. This is not really
possible with the current (and/or (cmp0), (cmp1)) implementations
which only work on already built CmpInst values.

This has come up before (prevent folds) in cases like: D154791

This NFC Refactors all (and/or (cmp0), (cmp1)) to take a new struct
CmpComponents instead of an CmpInst *. CmpComponents just holds
the Predicate, and LHS/RHS Value but doesn't require actually
committing to building a new instruction. This means all the `(and/or
(cmp0), (cmp1))` folds can be checked without having to actually build
a CmpInst.

This patch is preperatory for a refactor of LogicalAnd/LogicalOr
handling.

[goldstein.w.n]

Rebase

[goldstein.w.n]

Abandoning and resubmitting on GH

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

 }
 
 /// Handle (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E).
 /// Return the pattern classes (from MaskedICmpType) for the left hand side and
 /// the right hand side as a pair.
 /// LHS and RHS are the left hand side and the right hand side ICmps and PredL
 /// and PredR are their predicates, respectively.
 static std::optional<std::pair<unsigned, unsigned>> getMaskedTypeForICmpPair(
-    Value *&A, Value *&B, Value *&C, Value *&D, Value *&E, ICmpInst *LHS,
-    ICmpInst *RHS, ICmpInst::Predicate &PredL, ICmpInst::Predicate &PredR) {
+    Value *&A, Value *&B, Value *&C, Value *&D, Value *&E,
+    InstCombinerImpl::ICmpComponents LHS, InstCombinerImpl::ICmpComponents RHS,
+    ICmpInst::Predicate &PredL, ICmpInst::Predicate &PredR) {
   // Don't allow pointers. Splat vectors are fine.
-  if (!LHS->getOperand(0)->getType()->isIntOrIntVectorTy() ||
-      !RHS->getOperand(0)->getType()->isIntOrIntVectorTy())
+  if (!LHS.getOperand(0)->getType()->isIntOrIntVectorTy() ||
+      !RHS.getOperand(0)->getType()->isIntOrIntVectorTy())
     return std::nullopt;
 
   // Here comes the tricky part:
   // LHS might be of the form L11 & L12 == X, X == L21 & L22,
   // and L11 & L12 == L21 & L22. The same goes for RHS.
   // Now we must find those components L** and R**, that are equal, so
   // that we can extract the parameters A, B, C, D, and E for the canonical
   // above.
-  Value *L1 = LHS->getOperand(0);
-  Value *L2 = LHS->getOperand(1);
+  Value *L1 = LHS.getOperand(0);
+  Value *L2 = LHS.getOperand(1);
   Value *L11, *L12, *L21, *L22;
   // Check whether the icmp can be decomposed into a bit test.
   if (decomposeBitTestICmp(L1, L2, PredL, L11, L12, L2)) {
     L21 = L22 = L1 = nullptr;
   } else {
     // Look for ANDs in the LHS icmp.
     if (!match(L1, m_And(m_Value(L11), m_Value(L12)))) {
       // Any icmp can be viewed as being trivially masked; if it allows us to
       // remove one, it's worth it.
       L11 = L1;
       L12 = Constant::getAllOnesValue(L1->getType());
     }
 
     if (!match(L2, m_And(m_Value(L21), m_Value(L22)))) {
       L21 = L2;
       L22 = Constant::getAllOnesValue(L2->getType());
     }
   }
 
   // Bail if LHS was a icmp that can't be decomposed into an equality.
   if (!ICmpInst::isEquality(PredL))
     return std::nullopt;
 
-  Value *R1 = RHS->getOperand(0);
-  Value *R2 = RHS->getOperand(1);
+  Value *R1 = RHS.getOperand(0);
+  Value *R2 = RHS.getOperand(1);
   Value *R11, *R12;
   bool Ok = false;
   if (decomposeBitTestICmp(R1, R2, PredR, R11, R12, R2)) {
     if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) {
       A = R11;
       D = R12;
     } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) {
       A = R12;

 }
 
 /// Try to fold (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E) into a single
 /// (icmp(A & X) ==/!= Y), where the left-hand side is of type Mask_NotAllZeros
 /// and the right hand side is of type BMask_Mixed. For example,
 /// (icmp (A & 12) != 0) & (icmp (A & 15) == 8) -> (icmp (A & 15) == 8).
 /// Also used for logical and/or, must be poison safe.
 static Value *foldLogOpOfMaskedICmps_NotAllZeros_BMask_Mixed(
-    ICmpInst *LHS, ICmpInst *RHS, bool IsAnd, Value *A, Value *B, Value *C,
-    Value *D, Value *E, ICmpInst::Predicate PredL, ICmpInst::Predicate PredR,
+    InstCombinerImpl::ICmpComponents LHS, InstCombinerImpl::ICmpComponents RHS,
+    bool IsAnd, Value *A, Value *B, Value *C, Value *D, Value *E,
+    ICmpInst::Predicate PredL, ICmpInst::Predicate PredR,
     InstCombiner::BuilderTy &Builder) {
   // We are given the canonical form:
   //   (icmp ne (A & B), 0) & (icmp eq (A & D), E).
   // where D & E == E.
   //
   // If IsAnd is false, we get it in negated form:
   //   (icmp eq (A & B), 0) | (icmp ne (A & D), E) ->
   //      !((icmp ne (A & B), 0) & (icmp eq (A & D), E)).
static Value *foldLogOpOfMaskedICmps_NotAllZeros_BMask_Mixed(
   // If E is zero, if B is a subset of (or equal to) D, LHS and RHS contradict
   // and the whole expression becomes false (or true if negated), otherwise, no
   // folding.
   // For example,
   // (icmp ne (A & 3), 0) & (icmp eq (A & 7), 0) -> false.
   // (icmp ne (A & 15), 0) & (icmp eq (A & 3), 0) -> no folding.
   if (ECst.isZero()) {
     if (IsSubSetOrEqual(BCst, DCst))
-      return ConstantInt::get(LHS->getType(), !IsAnd);
+      return ConstantInt::get(LHS.getType(), !IsAnd);
     return nullptr;
   }
 
   // At this point, B, D, E aren't zero and (B & D) == B, (B & D) == D or B ==
   // D. If B is a superset of (or equal to) D, since E is not zero, LHS is
   // subsumed by RHS (RHS implies LHS.) So the whole expression becomes
   // RHS. For example,
   // (icmp ne (A & 255), 0) & (icmp eq (A & 15), 8) -> (icmp eq (A & 15), 8).
   // (icmp ne (A & 15), 0) & (icmp eq (A & 15), 8) -> (icmp eq (A & 15), 8).
   if (IsSuperSetOrEqual(BCst, DCst))
-    return RHS;
+    return RHS.getOrCreateValue(Builder);
   // Otherwise, B is a subset of D. If B and E have a common bit set,
   // ie. (B & E) != 0, then LHS is subsumed by RHS. For example.
   // (icmp ne (A & 12), 0) & (icmp eq (A & 15), 8) -> (icmp eq (A & 15), 8).
   assert(IsSubSetOrEqual(BCst, DCst) && "Precondition due to above code");
   if ((*BCst & ECst) != 0)
-    return RHS;
+    return RHS.getOrCreateValue(Builder);
   // Otherwise, LHS and RHS contradict and the whole expression becomes false
   // (or true if negated.) For example,
   // (icmp ne (A & 7), 0) & (icmp eq (A & 15), 8) -> false.
   // (icmp ne (A & 6), 0) & (icmp eq (A & 15), 8) -> false.
-  return ConstantInt::get(LHS->getType(), !IsAnd);
+  return ConstantInt::get(LHS.getType(), !IsAnd);
 }
 
 /// Try to fold (icmp(A & B) ==/!= 0) &/| (icmp(A & D) ==/!= E) into a single
 /// (icmp(A & X) ==/!= Y), where the left-hand side and the right hand side
 /// aren't of the common mask pattern type.
 /// Also used for logical and/or, must be poison safe.
 static Value *foldLogOpOfMaskedICmpsAsymmetric(
-    ICmpInst *LHS, ICmpInst *RHS, bool IsAnd, Value *A, Value *B, Value *C,
-    Value *D, Value *E, ICmpInst::Predicate PredL, ICmpInst::Predicate PredR,
-    unsigned LHSMask, unsigned RHSMask, InstCombiner::BuilderTy &Builder) {
+    InstCombinerImpl::ICmpComponents LHS, InstCombinerImpl::ICmpComponents RHS,
+    bool IsAnd, Value *A, Value *B, Value *C, Value *D, Value *E,
+    ICmpInst::Predicate PredL, ICmpInst::Predicate PredR, unsigned LHSMask,
+    unsigned RHSMask, InstCombiner::BuilderTy &Builder) {
   assert(ICmpInst::isEquality(PredL) && ICmpInst::isEquality(PredR) &&
          "Expected equality predicates for masked type of icmps.");
   // Handle Mask_NotAllZeros-BMask_Mixed cases.
   // (icmp ne/eq (A & B), C) &/| (icmp eq/ne (A & D), E), or
   // (icmp eq/ne (A & B), C) &/| (icmp ne/eq (A & D), E)
   //    which gets swapped to
   //    (icmp ne/eq (A & D), E) &/| (icmp eq/ne (A & B), C).
   if (!IsAnd) {
if (Value *V = foldLogOpOfMaskedICmps_NotAllZeros_BMask_Mixed(
       return V;
     }
   }
   return nullptr;
 }
 
 /// Try to fold (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E)
 /// into a single (icmp(A & X) ==/!= Y).
-static Value *foldLogOpOfMaskedICmps(ICmpInst *LHS, ICmpInst *RHS, bool IsAnd,
-                                     bool IsLogical,
+static Value *foldLogOpOfMaskedICmps(InstCombinerImpl::ICmpComponents LHS,
+                                     InstCombinerImpl::ICmpComponents RHS,
+                                     bool IsAnd, bool IsLogical,
                                      InstCombiner::BuilderTy &Builder) {
   Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr, *E = nullptr;
-  ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
+  ICmpInst::Predicate PredL = LHS.getPredicate(), PredR = RHS.getPredicate();
   std::optional<std::pair<unsigned, unsigned>> MaskPair =
       getMaskedTypeForICmpPair(A, B, C, D, E, LHS, RHS, PredL, PredR);
   if (!MaskPair)
     return nullptr;
   assert(ICmpInst::isEquality(PredL) && ICmpInst::isEquality(PredR) &&
          "Expected equality predicates for masked type of icmps.");
   unsigned LHSMask = MaskPair->first;
   unsigned RHSMask = MaskPair->second;
static Value *foldLogOpOfMaskedICmps(InstCombinerImpl::ICmpComponents LHS,
   if (Mask & (Mask_NotAllZeros | BMask_NotAllOnes)) {
     // (icmp ne (A & B), 0) & (icmp ne (A & D), 0) and
     // (icmp ne (A & B), B) & (icmp ne (A & D), D)
     //     -> (icmp ne (A & B), 0) or (icmp ne (A & D), 0)
     // Only valid if one of the masks is a superset of the other (check "B&D" is
     // the same as either B or D).
     APInt NewMask = *ConstB & *ConstD;
     if (NewMask == *ConstB)
-      return LHS;
+      return LHS.getOrCreateValue(Builder);
     else if (NewMask == *ConstD)
-      return RHS;
+      return RHS.getOrCreateValue(Builder);
   }
 
   if (Mask & AMask_NotAllOnes) {
     // (icmp ne (A & B), B) & (icmp ne (A & D), D)
     //     -> (icmp ne (A & B), A) or (icmp ne (A & D), A)
     // Only valid if one of the masks is a superset of the other (check "B|D" is
     // the same as either B or D).
     APInt NewMask = *ConstB | *ConstD;
     if (NewMask == *ConstB)
-      return LHS;
+      return LHS.getOrCreateValue(Builder);
     else if (NewMask == *ConstD)
-      return RHS;
+      return RHS.getOrCreateValue(Builder);
   }
 
   if (Mask & (BMask_Mixed | BMask_NotMixed)) {
     // Mixed:
     // (icmp eq (A & B), C) & (icmp eq (A & D), E)
     // We already know that B & C == C && D & E == E.
     // If we can prove that (B & D) & (C ^ E) == 0, that is, the bits of
     // C and E, which are shared by both the mask B and the mask D, don't
if (!match(C, m_APInt(OldConstC)) || !match(E, m_APInt(OldConstE)))
       return nullptr;
 
     auto FoldBMixed = [&](ICmpInst::Predicate CC, bool IsNot) -> Value * {
       CC = IsNot ? CmpInst::getInversePredicate(CC) : CC;
       const APInt ConstC = PredL != CC ? *ConstB ^ *OldConstC : *OldConstC;
       const APInt ConstE = PredR != CC ? *ConstD ^ *OldConstE : *OldConstE;
 
       if (((*ConstB & *ConstD) & (ConstC ^ ConstE)).getBoolValue())
-        return IsNot ? nullptr : ConstantInt::get(LHS->getType(), !IsAnd);
+        return IsNot ? nullptr
+                     : ConstantInt::get(LHS.getType(), !IsAnd);
 
       if (IsNot && !ConstB->isSubsetOf(*ConstD) && !ConstD->isSubsetOf(*ConstB))
         return nullptr;
 
       APInt BD, CE;
       if (IsNot) {
         BD = *ConstB & *ConstD;
         CE = ConstC & ConstE;
static Value *foldLogOpOfMaskedICmps(InstCombinerImpl::ICmpComponents LHS,
   }
   return nullptr;
 }
 
 /// Try to fold a signed range checked with lower bound 0 to an unsigned icmp.
 /// Example: (icmp sge x, 0) & (icmp slt x, n) --> icmp ult x, n
 /// If \p Inverted is true then the check is for the inverted range, e.g.
 /// (icmp slt x, 0) | (icmp sgt x, n) --> icmp ugt x, n
-Value *InstCombinerImpl::simplifyRangeCheck(ICmpInst *Cmp0, ICmpInst *Cmp1,
-                                            bool Inverted) {
+Value *
+InstCombinerImpl::simplifyRangeCheck(InstCombinerImpl::ICmpComponents Cmp0,
+                                     InstCombinerImpl::ICmpComponents Cmp1,
   // Check the lower range comparison, e.g. x >= 0
   // InstCombine already ensured that if there is a constant it's on the RHS.
-  ConstantInt *RangeStart = dyn_cast<ConstantInt>(Cmp0->getOperand(1));
+  ConstantInt *RangeStart = dyn_cast<ConstantInt>(Cmp0.getOperand(1));
   if (!RangeStart)
     return nullptr;
 
-  ICmpInst::Predicate Pred0 = (Inverted ? Cmp0->getInversePredicate() :
-                               Cmp0->getPredicate());
+  ICmpInst::Predicate Pred0 =
+      (Inverted ? Cmp0.getInversePredicate() : Cmp0.getPredicate());
 
   // Accept x > -1 or x >= 0 (after potentially inverting the predicate).
   if (!((Pred0 == ICmpInst::ICMP_SGT && RangeStart->isMinusOne()) ||
         (Pred0 == ICmpInst::ICMP_SGE && RangeStart->isZero())))
     return nullptr;
 
-  ICmpInst::Predicate Pred1 = (Inverted ? Cmp1->getInversePredicate() :
-                               Cmp1->getPredicate());
+  ICmpInst::Predicate Pred1 =
+      (Inverted ? Cmp1.getInversePredicate() : Cmp1.getPredicate());
 
-  Value *Input = Cmp0->getOperand(0);
+  Value *Input = Cmp0.getOperand(0);
   Value *RangeEnd;
-  if (Cmp1->getOperand(0) == Input) {
+  if (Cmp1.getOperand(0) == Input) {
     // For the upper range compare we have: icmp x, n
-    RangeEnd = Cmp1->getOperand(1);
-  } else if (Cmp1->getOperand(1) == Input) {
+    RangeEnd = Cmp1.getOperand(1);
+  } else if (Cmp1.getOperand(1) == Input) {
     // For the upper range compare we have: icmp n, x
-    RangeEnd = Cmp1->getOperand(0);
+    RangeEnd = Cmp1.getOperand(0);
     Pred1 = ICmpInst::getSwappedPredicate(Pred1);
   } else {
     return nullptr;
   }
 
   // Check the upper range comparison, e.g. x < n
   ICmpInst::Predicate NewPred;
   switch (Pred1) {
     case ICmpInst::ICMP_SLT: NewPred = ICmpInst::ICMP_ULT; break;
     case ICmpInst::ICMP_SLE: NewPred = ICmpInst::ICMP_ULE; break;
     default: return nullptr;
   }
 
   // This simplification is only valid if the upper range is not negative.
-  KnownBits Known = computeKnownBits(RangeEnd, /*Depth=*/0, Cmp1);
+  KnownBits Known = computeKnownBits(RangeEnd, /*Depth=*/0, Cmp1.OrigCmp_);
   if (!Known.isNonNegative())
     return nullptr;
 
   if (Inverted)
     NewPred = ICmpInst::getInversePredicate(NewPred);
 
   return Builder.CreateICmp(NewPred, Input, RangeEnd);
 }
 
 // Fold (iszero(A & K1) | iszero(A & K2)) -> (A & (K1 | K2)) != (K1 | K2)
 // Fold (!iszero(A & K1) & !iszero(A & K2)) -> (A & (K1 | K2)) == (K1 | K2)
-Value *InstCombinerImpl::foldAndOrOfICmpsOfAndWithPow2(ICmpInst *LHS,
-                                                       ICmpInst *RHS,
-                                                       Instruction *CxtI,
-                                                       bool IsAnd,
-                                                       bool IsLogical) {
+Value *InstCombinerImpl::foldAndOrOfICmpsOfAndWithPow2(
+    InstCombinerImpl::ICmpComponents LHS, InstCombinerImpl::ICmpComponents RHS,
+    Instruction *CxtI, bool IsAnd, bool IsLogical) {
   CmpInst::Predicate Pred = IsAnd ? CmpInst::ICMP_NE : CmpInst::ICMP_EQ;
-  if (LHS->getPredicate() != Pred || RHS->getPredicate() != Pred)
+  if (LHS.getPredicate() != Pred || RHS.getPredicate() != Pred)
     return nullptr;
 
-  if (!match(LHS->getOperand(1), m_Zero()) ||
-      !match(RHS->getOperand(1), m_Zero()))
+  if (!match(LHS.getOperand(1), m_Zero()) ||
+      !match(RHS.getOperand(1), m_Zero()))
     return nullptr;
 
   Value *L1, *L2, *R1, *R2;
-  if (match(LHS->getOperand(0), m_And(m_Value(L1), m_Value(L2))) &&
-      match(RHS->getOperand(0), m_And(m_Value(R1), m_Value(R2)))) {
+  if (match(LHS.getOperand(0), m_And(m_Value(L1), m_Value(L2))) &&
+      match(RHS.getOperand(0), m_And(m_Value(R1), m_Value(R2)))) {
     if (L1 == R2 || L2 == R2)
       std::swap(R1, R2);
     if (L2 == R1)
       std::swap(L1, L2);
 
     if (L1 == R1 &&
         isKnownToBeAPowerOfTwo(L2, false, 0, CxtI) &&
         isKnownToBeAPowerOfTwo(R2, false, 0, CxtI)) {

 ///   %t = and      i32   %arg,    2147483648
 ///   %r = icmp eq  i32   %t,      0
 ///
 /// Since we are checking that all the bits in that mask are the same,
 /// and a particular bit is zero, what we are really checking is that all the
 /// masked bits are zero.
 /// So this should be transformed to:
 ///   %r = icmp ult i32 %arg, 128
-static Value *foldSignedTruncationCheck(ICmpInst *ICmp0, ICmpInst *ICmp1,
+static Value *foldSignedTruncationCheck(InstCombinerImpl::ICmpComponents ICmp0,
+                                        InstCombinerImpl::ICmpComponents ICmp1,
                                         Instruction &CxtI,
                                         InstCombiner::BuilderTy &Builder) {
   assert(CxtI.getOpcode() == Instruction::And);
 
   // Match  icmp ult (add %arg, C01), C1   (C1 == C01 << 1; powers of two)
-  auto tryToMatchSignedTruncationCheck = [](ICmpInst *ICmp, Value *&X,
-                                            APInt &SignBitMask) -> bool {
+
+  auto tryToMatchSignedTruncationCheck =
+      [](InstCombinerImpl::ICmpComponents ICmp, Value *&X,
     CmpInst::Predicate Pred;
     const APInt *I01, *I1; // powers of two; I1 == I01 << 1
-    if (!(match(ICmp,
-                m_ICmp(Pred, m_Add(m_Value(X), m_Power2(I01)), m_Power2(I1))) &&
-          Pred == ICmpInst::ICMP_ULT && I1->ugt(*I01) && I01->shl(1) == *I1))
+
+    if (!match(ICmp.getOperand(0), m_Add(m_Value(X), m_Power2(I01))) ||
+        !match(ICmp.getOperand(1), m_Power2(I1)))
+      return false;
+    Pred = ICmp.getPredicate();
+    if (Pred != ICmpInst::ICMP_ULT || I1->ule(*I01) || I01->shl(1) != *I1)
       return false;
     // Which bit is the new sign bit as per the 'signed truncation' pattern?
     SignBitMask = *I01;
     return true;
   };
 
   // One icmp needs to be 'signed truncation check'.
   // We need to match this first, else we will mismatch commutative cases.
   Value *X1;
   APInt HighestBit;
-  ICmpInst *OtherICmp;
+  InstCombinerImpl::ICmpComponents OtherICmp;
   if (tryToMatchSignedTruncationCheck(ICmp1, X1, HighestBit))
     OtherICmp = ICmp0;
   else if (tryToMatchSignedTruncationCheck(ICmp0, X1, HighestBit))
     OtherICmp = ICmp1;
   else
     return nullptr;
 
   assert(HighestBit.isPowerOf2() && "expected to be power of two (non-zero)");
 
   // Try to match/decompose into:  icmp eq (X & Mask), 0
-  auto tryToDecompose = [](ICmpInst *ICmp, Value *&X,
+  auto tryToDecompose = [](InstCombinerImpl::ICmpComponents ICmp, Value *&X,
                            APInt &UnsetBitsMask) -> bool {
-    CmpInst::Predicate Pred = ICmp->getPredicate();
+    CmpInst::Predicate Pred = ICmp.getPredicate();
     // Can it be decomposed into  icmp eq (X & Mask), 0  ?
-    if (llvm::decomposeBitTestICmp(ICmp->getOperand(0), ICmp->getOperand(1),
-                                   Pred, X, UnsetBitsMask,
+    if (llvm::decomposeBitTestICmp(ICmp.getOperand(0), ICmp.getOperand(1), Pred,
+                                   X, UnsetBitsMask,
                                    /*LookThroughTrunc=*/false) &&
         Pred == ICmpInst::ICMP_EQ)
       return true;
     // Is it  icmp eq (X & Mask), 0  already?
     const APInt *Mask;
-    if (match(ICmp, m_ICmp(Pred, m_And(m_Value(X), m_APInt(Mask)), m_Zero())) &&
-        Pred == ICmpInst::ICMP_EQ) {
+
+    if (match(ICmp.getOperand(0), m_And(m_Value(X), m_APInt(Mask))) &&
+        match(ICmp.getOperand(1), m_Zero()) && Pred == ICmpInst::ICMP_EQ) {
       UnsetBitsMask = *Mask;
       return true;
     }
     return false;
   };
 
   // And the other icmp needs to be decomposable into a bit test.
   Value *X0;
static Value *foldSignedTruncationCheck(InstCombinerImpl::ICmpComponents ICmp0,
   // %r = icmp ult %X, SignBit
   return Builder.CreateICmpULT(X, ConstantInt::get(X->getType(), HighestBit),
                                CxtI.getName() + ".simplified");
 }
 
 /// Fold (icmp eq ctpop(X) 1) | (icmp eq X 0) into (icmp ult ctpop(X) 2) and
 /// fold (icmp ne ctpop(X) 1) & (icmp ne X 0) into (icmp ugt ctpop(X) 1).
 /// Also used for logical and/or, must be poison safe.
-static Value *foldIsPowerOf2OrZero(ICmpInst *Cmp0, ICmpInst *Cmp1, bool IsAnd,
+static Value *foldIsPowerOf2OrZero(InstCombinerImpl::ICmpComponents Cmp0,
+                                   InstCombinerImpl::ICmpComponents Cmp1,
+                                   bool IsAnd,
                                    InstCombiner::BuilderTy &Builder) {
   CmpInst::Predicate Pred0, Pred1;
   Value *X;
-  if (!match(Cmp0, m_ICmp(Pred0, m_Intrinsic<Intrinsic::ctpop>(m_Value(X)),
-                          m_SpecificInt(1))) ||
-      !match(Cmp1, m_ICmp(Pred1, m_Specific(X), m_ZeroInt())))
+
+  Pred0 = Cmp0.getPredicate();
+  if (!match(Cmp0.getOperand(0), m_Intrinsic<Intrinsic::ctpop>(m_Value(X))) ||
+      !match(Cmp0.getOperand(1), m_SpecificInt(1)))
     return nullptr;
 
-  Value *CtPop = Cmp0->getOperand(0);
+  Pred1 = Cmp1.getPredicate();
+  if (Cmp1.getOperand(0) != X || !match(Cmp1.getOperand(1), m_ZeroInt()))
+    return nullptr;
+
+  Value *CtPop = Cmp0.getOperand(0);
   if (IsAnd && Pred0 == ICmpInst::ICMP_NE && Pred1 == ICmpInst::ICMP_NE)
     return Builder.CreateICmpUGT(CtPop, ConstantInt::get(CtPop->getType(), 1));
   if (!IsAnd && Pred0 == ICmpInst::ICMP_EQ && Pred1 == ICmpInst::ICMP_EQ)
     return Builder.CreateICmpULT(CtPop, ConstantInt::get(CtPop->getType(), 2));
 
   return nullptr;
 }
 
 /// Reduce a pair of compares that check if a value has exactly 1 bit set.
 /// Also used for logical and/or, must be poison safe.
-static Value *foldIsPowerOf2(ICmpInst *Cmp0, ICmpInst *Cmp1, bool JoinedByAnd,
+static Value *foldIsPowerOf2(InstCombinerImpl::ICmpComponents Cmp0,
+                             InstCombinerImpl::ICmpComponents Cmp1,
+                             bool JoinedByAnd,
                              InstCombiner::BuilderTy &Builder) {
   // Handle 'and' / 'or' commutation: make the equality check the first operand.
-  if (JoinedByAnd && Cmp1->getPredicate() == ICmpInst::ICMP_NE)
+  if (JoinedByAnd && Cmp1.getPredicate() == ICmpInst::ICMP_NE)
     std::swap(Cmp0, Cmp1);
-  else if (!JoinedByAnd && Cmp1->getPredicate() == ICmpInst::ICMP_EQ)
+  else if (!JoinedByAnd && Cmp1.getPredicate() == ICmpInst::ICMP_EQ)
     std::swap(Cmp0, Cmp1);
 
   // (X != 0) && (ctpop(X) u< 2) --> ctpop(X) == 1
   CmpInst::Predicate Pred0, Pred1;
   Value *X;
-  if (JoinedByAnd && match(Cmp0, m_ICmp(Pred0, m_Value(X), m_ZeroInt())) &&
-      match(Cmp1, m_ICmp(Pred1, m_Intrinsic<Intrinsic::ctpop>(m_Specific(X)),
-                         m_SpecificInt(2))) &&
+
+  Pred0 = Cmp0.getPredicate();
+  X = Cmp0.getOperand(0);
+  Pred1 = Cmp1.getPredicate();
+  if (JoinedByAnd && match(Cmp0.getOperand(1), m_ZeroInt()) &&
+      match(Cmp1.getOperand(0), m_Intrinsic<Intrinsic::ctpop>(m_Specific(X))) &&
+      match(Cmp1.getOperand(1), m_SpecificInt(2)) &&
       Pred0 == ICmpInst::ICMP_NE && Pred1 == ICmpInst::ICMP_ULT) {
-    Value *CtPop = Cmp1->getOperand(0);
+    Value *CtPop = Cmp1.getOperand(0);
     return Builder.CreateICmpEQ(CtPop, ConstantInt::get(CtPop->getType(), 1));
   }
+
   // (X == 0) || (ctpop(X) u> 1) --> ctpop(X) != 1
-  if (!JoinedByAnd && match(Cmp0, m_ICmp(Pred0, m_Value(X), m_ZeroInt())) &&
-      match(Cmp1, m_ICmp(Pred1, m_Intrinsic<Intrinsic::ctpop>(m_Specific(X)),
-                         m_SpecificInt(1))) &&
+  if (!JoinedByAnd && match(Cmp0.getOperand(1), m_ZeroInt()) &&
+      match(Cmp1.getOperand(0), m_Intrinsic<Intrinsic::ctpop>(m_Specific(X))) &&
+      match(Cmp1.getOperand(1), m_SpecificInt(1)) &&
       Pred0 == ICmpInst::ICMP_EQ && Pred1 == ICmpInst::ICMP_UGT) {
-    Value *CtPop = Cmp1->getOperand(0);
+    Value *CtPop = Cmp1.getOperand(0);
     return Builder.CreateICmpNE(CtPop, ConstantInt::get(CtPop->getType(), 1));
   }
+
   return nullptr;
 }
 
 /// Try to fold (icmp(A & B) == 0) & (icmp(A & D) != E) into (icmp A u< D) iff
 /// B is a contiguous set of ones starting from the most significant bit
 /// (negative power of 2), D and E are equal, and D is a contiguous set of ones
 /// starting at the most significant zero bit in B. Parameter B supports masking
 /// using undef/poison in either scalar or vector values.

 
 /// Try to fold ((icmp X u< P) & (icmp(X & M) != M)) or ((icmp X s> -1) &
 /// (icmp(X & M) != M)) into (icmp X u< M). Where P is a power of 2, M < P, and
 /// M is a contiguous shifted mask starting at the right most significant zero
 /// bit in P. SGT is supported as when P is the largest representable power of
 /// 2, an earlier optimization converts the expression into (icmp X s> -1).
 /// Parameter P supports masking using undef/poison in either scalar or vector
 /// values.
-static Value *foldPowerOf2AndShiftedMask(ICmpInst *Cmp0, ICmpInst *Cmp1,
+static Value *foldPowerOf2AndShiftedMask(InstCombinerImpl::ICmpComponents Cmp0,
+                                         InstCombinerImpl::ICmpComponents Cmp1,
                                          bool JoinedByAnd,
                                          InstCombiner::BuilderTy &Builder) {
   if (!JoinedByAnd)
     return nullptr;
   Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr, *E = nullptr;
-  ICmpInst::Predicate CmpPred0 = Cmp0->getPredicate(),
-                      CmpPred1 = Cmp1->getPredicate();
+  ICmpInst::Predicate CmpPred0 = Cmp0.getPredicate(),
+                      CmpPred1 = Cmp1.getPredicate();
   // Assuming P is a 2^n, getMaskedTypeForICmpPair will normalize (icmp X u<
   // 2^n) into (icmp (X & ~(2^n-1)) == 0) and (icmp X s> -1) into (icmp (X &
   // SignMask) == 0).
   std::optional<std::pair<unsigned, unsigned>> MaskPair =
       getMaskedTypeForICmpPair(A, B, C, D, E, Cmp0, Cmp1, CmpPred0, CmpPred1);
   if (!MaskPair)
     return nullptr;
 
if (Value *V = foldNegativePower2AndShiftedMask(A, D, B, C, CmpPred1,
                                                     CmpPred0, Builder))
       return V;
   }
   return nullptr;
 }
 
 /// Commuted variants are assumed to be handled by calling this function again
 /// with the parameters swapped.
-static Value *foldUnsignedUnderflowCheck(ICmpInst *ZeroICmp,
-                                         ICmpInst *UnsignedICmp, bool IsAnd,
-                                         const SimplifyQuery &Q,
-                                         InstCombiner::BuilderTy &Builder) {
+static Value *
+foldUnsignedUnderflowCheck(InstCombinerImpl::ICmpComponents ZeroICmp,
+                           InstCombinerImpl::ICmpComponents UnsignedICmp,
+                           bool IsAnd, const SimplifyQuery &Q,
   Value *ZeroCmpOp;
   ICmpInst::Predicate EqPred;
-  if (!match(ZeroICmp, m_ICmp(EqPred, m_Value(ZeroCmpOp), m_Zero())) ||
-      !ICmpInst::isEquality(EqPred))
+
+  EqPred = ZeroICmp.getPredicate();
+  ZeroCmpOp = ZeroICmp.getOperand(0);
+  if (!match(ZeroICmp.getOperand(1), m_Zero()) || !ICmpInst::isEquality(EqPred))
     return nullptr;
 
   auto IsKnownNonZero = [&](Value *V) {
     return isKnownNonZero(V, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT);
   };
 
   ICmpInst::Predicate UnsignedPred;
+  Value *A = nullptr, *B;
 
-  Value *A, *B;
-  if (match(UnsignedICmp,
-            m_c_ICmp(UnsignedPred, m_Specific(ZeroCmpOp), m_Value(A))) &&
-      match(ZeroCmpOp, m_c_Add(m_Specific(A), m_Value(B))) &&
-      (ZeroICmp->hasOneUse() || UnsignedICmp->hasOneUse())) {
+  if (ZeroCmpOp == UnsignedICmp.getOperand(0)) {
+    A = UnsignedICmp.getOperand(1);
+    UnsignedPred = UnsignedICmp.getPredicate();
+  } else if (ZeroCmpOp == UnsignedICmp.getOperand(1)) {
+    A = UnsignedICmp.getOperand(0);
+    UnsignedPred = UnsignedICmp.getSwappedPredicate();
+  }
+
+  if (A != nullptr && match(ZeroCmpOp, m_c_Add(m_Specific(A), m_Value(B))) &&
+      (ZeroICmp.hasOneUse() || UnsignedICmp.hasOneUse())) {
     auto GetKnownNonZeroAndOther = [&](Value *&NonZero, Value *&Other) {
       if (!IsKnownNonZero(NonZero))
         std::swap(NonZero, Other);
       return IsKnownNonZero(NonZero);
     };
 
     // Given  ZeroCmpOp = (A + B)
     //   ZeroCmpOp <  A && ZeroCmpOp != 0  -->  (0-X) <  Y  iff
     //   ZeroCmpOp >= A || ZeroCmpOp == 0  -->  (0-X) >= Y  iff
     //     with X being the value (A/B) that is known to be non-zero,
     //     and Y being remaining value.
     if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_NE &&
         IsAnd && GetKnownNonZeroAndOther(B, A))
       return Builder.CreateICmpULT(Builder.CreateNeg(B), A);
     if (UnsignedPred == ICmpInst::ICMP_UGE && EqPred == ICmpInst::ICMP_EQ &&
         !IsAnd && GetKnownNonZeroAndOther(B, A))
       return Builder.CreateICmpUGE(Builder.CreateNeg(B), A);
   }
 
   Value *Base, *Offset;
   if (!match(ZeroCmpOp, m_Sub(m_Value(Base), m_Value(Offset))))
     return nullptr;
 
-  if (!match(UnsignedICmp,
-             m_c_ICmp(UnsignedPred, m_Specific(Base), m_Specific(Offset))) ||
-      !ICmpInst::isUnsigned(UnsignedPred))
+  if (UnsignedICmp.getOperand(0) == Base &&
+      UnsignedICmp.getOperand(1) == Offset)
+    UnsignedPred = UnsignedICmp.getPredicate();
+  else if (UnsignedICmp.getOperand(1) == Base &&
+           UnsignedICmp.getOperand(0) == Offset)
+    UnsignedPred = UnsignedICmp.getSwappedPredicate();
+  else
+    return nullptr;
+
+  if (!ICmpInst::isUnsigned(UnsignedPred))
     return nullptr;
 
   // Base >=/> Offset && (Base - Offset) != 0  <-->  Base > Offset
   // (no overflow and not null)
   if ((UnsignedPred == ICmpInst::ICMP_UGE ||
        UnsignedPred == ICmpInst::ICMP_UGT) &&
       EqPred == ICmpInst::ICMP_NE && IsAnd)
     return Builder.CreateICmpUGT(Base, Offset);
static Value *extractIntPart(const IntPart &P, IRBuilderBase &Builder) {
   if (TruncTy != V->getType())
     V = Builder.CreateTrunc(V, TruncTy);
   return V;
 }
 
 /// (icmp eq X0, Y0) & (icmp eq X1, Y1) -> icmp eq X01, Y01
 /// (icmp ne X0, Y0) | (icmp ne X1, Y1) -> icmp ne X01, Y01
 /// where X0, X1 and Y0, Y1 are adjacent parts extracted from an integer.
-Value *InstCombinerImpl::foldEqOfParts(ICmpInst *Cmp0, ICmpInst *Cmp1,
+Value *InstCombinerImpl::foldEqOfParts(InstCombinerImpl::ICmpComponents Cmp0,
+                                       InstCombinerImpl::ICmpComponents Cmp1,
                                        bool IsAnd) {
-  if (!Cmp0->hasOneUse() || !Cmp1->hasOneUse())
+  if (!Cmp0.hasOneUse() || !Cmp1.hasOneUse())
     return nullptr;
 
   CmpInst::Predicate Pred = IsAnd ? CmpInst::ICMP_EQ : CmpInst::ICMP_NE;
-  if (Cmp0->getPredicate() != Pred || Cmp1->getPredicate() != Pred)
+  if (Cmp0.getPredicate() != Pred || Cmp1.getPredicate() != Pred)
     return nullptr;
 
-  std::optional<IntPart> L0 = matchIntPart(Cmp0->getOperand(0));
-  std::optional<IntPart> R0 = matchIntPart(Cmp0->getOperand(1));
-  std::optional<IntPart> L1 = matchIntPart(Cmp1->getOperand(0));
-  std::optional<IntPart> R1 = matchIntPart(Cmp1->getOperand(1));
+  std::optional<IntPart> L0 = matchIntPart(Cmp0.getOperand(0));
+  std::optional<IntPart> R0 = matchIntPart(Cmp0.getOperand(1));
+  std::optional<IntPart> L1 = matchIntPart(Cmp1.getOperand(0));
+  std::optional<IntPart> R1 = matchIntPart(Cmp1.getOperand(1));
   if (!L0 || !R0 || !L1 || !R1)
     return nullptr;
 
   // Make sure the LHS/RHS compare a part of the same value, possibly after
   // an operand swap.
   if (L0->From != L1->From || R0->From != R1->From) {
     if (L0->From != R1->From || R0->From != L1->From)
       return nullptr;
Value *InstCombinerImpl::foldEqOfParts(InstCombinerImpl::ICmpComponents Cmp0,
   Value *LValue = extractIntPart(L, Builder);
   Value *RValue = extractIntPart(R, Builder);
   return Builder.CreateICmp(Pred, LValue, RValue);
 }
 
 /// Reduce logic-of-compares with equality to a constant by substituting a
 /// common operand with the constant. Callers are expected to call this with
 /// Cmp0/Cmp1 switched to handle logic op commutativity.
-static Value *foldAndOrOfICmpsWithConstEq(ICmpInst *Cmp0, ICmpInst *Cmp1,
+static Value *foldAndOrOfICmpsWithConstEq(InstCombinerImpl::ICmpComponents Cmp0,
+                                          InstCombinerImpl::ICmpComponents Cmp1,
                                           bool IsAnd, bool IsLogical,
                                           InstCombiner::BuilderTy &Builder,
                                           const SimplifyQuery &Q) {
   // Match an equality compare with a non-poison constant as Cmp0.
   // Also, give up if the compare can be constant-folded to avoid looping.
-  ICmpInst::Predicate Pred0;
-  Value *X;
+
+  ICmpInst::Predicate Pred0 = Cmp0.getPredicate();
+  Value *X = Cmp0.getOperand(0);
   Constant *C;
-  if (!match(Cmp0, m_ICmp(Pred0, m_Value(X), m_Constant(C))) ||
+
+  if (!match(Cmp0.getOperand(1), m_Constant(C)) ||
       !isGuaranteedNotToBeUndefOrPoison(C) || isa<Constant>(X))
     return nullptr;
+
   if ((IsAnd && Pred0 != ICmpInst::ICMP_EQ) ||
       (!IsAnd && Pred0 != ICmpInst::ICMP_NE))
     return nullptr;
 
   // The other compare must include a common operand (X). Canonicalize the
   // common operand as operand 1 (Pred1 is swapped if the common operand was
   // operand 0).
   Value *Y;
   ICmpInst::Predicate Pred1;
-  if (!match(Cmp1, m_c_ICmp(Pred1, m_Value(Y), m_Deferred(X))))
+
+  if (Cmp1.getOperand(1) == X) {
+    Y = Cmp1.getOperand(0);
+    Pred1 = Cmp1.getPredicate();
+  } else if (Cmp1.getOperand(0) == X) {
+    Y = Cmp1.getOperand(1);
+    Pred1 = Cmp1.getSwappedPredicate();
+  } else {
     return nullptr;
+  }
 
   // Replace variable with constant value equivalence to remove a variable use:
   // (X == C) && (Y Pred1 X) --> (X == C) && (Y Pred1 C)
   // (X != C) || (Y Pred1 X) --> (X != C) || (Y Pred1 C)
   // Can think of the 'or' substitution with the 'and' bool equivalent:
   // A || B --> A || (!A && B)
   Value *SubstituteCmp = simplifyICmpInst(Pred1, Y, C, Q);
   if (!SubstituteCmp) {
     // If we need to create a new instruction, require that the old compare can
     // be removed.
-    if (!Cmp1->hasOneUse())
+    if (!Cmp1.hasOneUse())
       return nullptr;
     SubstituteCmp = Builder.CreateICmp(Pred1, Y, C);
   }
+  Value *Cmp0V = Cmp0.getOrCreateValue(Builder);
   if (IsLogical)
-    return IsAnd ? Builder.CreateLogicalAnd(Cmp0, SubstituteCmp)
-                 : Builder.CreateLogicalOr(Cmp0, SubstituteCmp);
-  return Builder.CreateBinOp(IsAnd ? Instruction::And : Instruction::Or, Cmp0,
+    return IsAnd ? Builder.CreateLogicalAnd(Cmp0V, SubstituteCmp)
+                 : Builder.CreateLogicalOr(Cmp0V, SubstituteCmp);
+  return Builder.CreateBinOp(IsAnd ? Instruction::And : Instruction::Or, Cmp0V,
                              SubstituteCmp);
 }
 
 /// Fold (icmp Pred1 V1, C1) & (icmp Pred2 V2, C2)
 /// or   (icmp Pred1 V1, C1) | (icmp Pred2 V2, C2)
 /// into a single comparison using range-based reasoning.
 /// NOTE: This is also used for logical and/or, must be poison-safe!
-Value *InstCombinerImpl::foldAndOrOfICmpsUsingRanges(ICmpInst *ICmp1,
-                                                     ICmpInst *ICmp2,
-                                                     bool IsAnd) {
+Value *InstCombinerImpl::foldAndOrOfICmpsUsingRanges(
+    InstCombinerImpl::ICmpComponents ICmp1,
+    InstCombinerImpl::ICmpComponents ICmp2, bool IsAnd) {
   ICmpInst::Predicate Pred1, Pred2;
   Value *V1, *V2;
   const APInt *C1, *C2;
-  if (!match(ICmp1, m_ICmp(Pred1, m_Value(V1), m_APInt(C1))) ||
-      !match(ICmp2, m_ICmp(Pred2, m_Value(V2), m_APInt(C2))))
+  Pred1 = ICmp1.getPredicate();
+  Pred2 = ICmp2.getPredicate();
+  V1 = ICmp1.getOperand(0);
+  V2 = ICmp2.getOperand(0);
+  if (!match(ICmp1.getOperand(1), m_APInt(C1)) ||
+      !match(ICmp2.getOperand(1), m_APInt(C2)))
     return nullptr;
 
   // Look through add of a constant offset on V1, V2, or both operands. This
   // allows us to interpret the V + C' < C'' range idiom into a proper range.
   const APInt *Offset1 = nullptr, *Offset2 = nullptr;
   if (V1 != V2) {
     Value *X;
     if (match(V1, m_Add(m_Value(X), m_APInt(Offset1))))
ConstantRange CR2 = ConstantRange::makeExactICmpRegion(
       IsAnd ? ICmpInst::getInversePredicate(Pred2) : Pred2, *C2);
   if (Offset2)
     CR2 = CR2.subtract(*Offset2);
 
   Type *Ty = V1->getType();
   Value *NewV = V1;
   std::optional<ConstantRange> CR = CR1.exactUnionWith(CR2);
   if (!CR) {
-    if (!(ICmp1->hasOneUse() && ICmp2->hasOneUse()) || CR1.isWrappedSet() ||
+    if (!(ICmp1.hasOneUse() && ICmp2.hasOneUse()) || CR1.isWrappedSet() ||
         CR2.isWrappedSet())
       return nullptr;
 
     // Check whether we have equal-size ranges that only differ by one bit.
     // In that case we can apply a mask to map one range onto the other.
     APInt LowerDiff = CR1.getLower() ^ CR2.getLower();
     APInt UpperDiff = (CR1.getUpper() - 1) ^ (CR2.getUpper() - 1);
     APInt CR1Size = CR1.getUpper() - CR1.getLower();

 static bool matchUnorderedInfCompare(FCmpInst::Predicate P, Value *LHS,
                                      Value *RHS) {
   return FCmpInst::isUnordered(P) && match(RHS, m_Inf());
 }
 
 /// and (fcmp ord x, 0), (fcmp u* x, inf) -> fcmp o* x, inf
 ///
 /// Clang emits this pattern for doing an isfinite check in __builtin_isnormal.
-static Value *matchIsFiniteTest(InstCombiner::BuilderTy &Builder, FCmpInst *LHS,
-                                FCmpInst *RHS) {
-  Value *LHS0 = LHS->getOperand(0), *LHS1 = LHS->getOperand(1);
-  Value *RHS0 = RHS->getOperand(0), *RHS1 = RHS->getOperand(1);
-  FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
+static Value *matchIsFiniteTest(InstCombiner::BuilderTy &Builder,
+                                InstCombinerImpl::FCmpComponents LHS,
+                                InstCombinerImpl::FCmpComponents RHS) {
+  Value *LHS0 = LHS.getOperand(0), *LHS1 = LHS.getOperand(1);
+  Value *RHS0 = RHS.getOperand(0), *RHS1 = RHS.getOperand(1);
+  FCmpInst::Predicate PredL = LHS.getPredicate();
+  FCmpInst::Predicate PredR = RHS.getPredicate();
 
   if (!matchIsNotNaN(PredL, LHS0, LHS1) ||
       !matchUnorderedInfCompare(PredR, RHS0, RHS1))
     return nullptr;
 
   IRBuilder<>::FastMathFlagGuard FMFG(Builder);
-  FastMathFlags FMF = LHS->getFastMathFlags();
-  FMF &= RHS->getFastMathFlags();
+  FastMathFlags FMF = LHS.OrigCmp_->getFastMathFlags();
+  FMF &= RHS.OrigCmp_->getFastMathFlags();
   Builder.setFastMathFlags(FMF);
 
   return Builder.CreateFCmp(FCmpInst::getOrderedPredicate(PredR), RHS0, RHS1);
 }
 
-Value *InstCombinerImpl::foldLogicOfFCmps(FCmpInst *LHS, FCmpInst *RHS,
-                                          bool IsAnd, bool IsLogicalSelect) {
-  Value *LHS0 = LHS->getOperand(0), *LHS1 = LHS->getOperand(1);
-  Value *RHS0 = RHS->getOperand(0), *RHS1 = RHS->getOperand(1);
-  FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
+Value *InstCombinerImpl::foldLogicOfFCmps(FCmpComponents LHS,
+                                          FCmpComponents RHS, bool IsAnd,
+                                          bool IsLogicalSelect) {
+  Value *LHS0 = LHS.getOperand(0), *LHS1 = LHS.getOperand(1);
+  Value *RHS0 = RHS.getOperand(0), *RHS1 = RHS.getOperand(1);
+  FCmpInst::Predicate PredL = LHS.getPredicate();
+  FCmpInst::Predicate PredR = RHS.getPredicate();
 
   if (LHS0 == RHS1 && RHS0 == LHS1) {
     // Swap RHS operands to match LHS.
     PredR = FCmpInst::getSwappedPredicate(PredR);
     std::swap(RHS0, RHS1);
   }
 
   // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y).
Value *InstCombinerImpl::foldLogicOfFCmps(FCmpComponents LHS,
   if (LHS0 == RHS0 && LHS1 == RHS1) {
     unsigned FCmpCodeL = getFCmpCode(PredL);
     unsigned FCmpCodeR = getFCmpCode(PredR);
     unsigned NewPred = IsAnd ? FCmpCodeL & FCmpCodeR : FCmpCodeL | FCmpCodeR;
 
     // Intersect the fast math flags.
     // TODO: We can union the fast math flags unless this is a logical select.
     IRBuilder<>::FastMathFlagGuard FMFG(Builder);
-    FastMathFlags FMF = LHS->getFastMathFlags();
-    FMF &= RHS->getFastMathFlags();
+    FastMathFlags FMF = LHS.OrigCmp_->getFastMathFlags();
+    FMF &= RHS.OrigCmp_->getFastMathFlags();
     Builder.setFastMathFlags(FMF);
 
     return getFCmpValue(NewPred, LHS0, LHS1, Builder);
   }
 
   // This transform is not valid for a logical select.
   if (!IsLogicalSelect &&
       ((PredL == FCmpInst::FCMP_ORD && PredR == FCmpInst::FCMP_ORD && IsAnd) ||
if (Value *Right = matchIsFiniteTest(Builder, RHS, LHS))
       return Right;
   }
 
   // Turn at least two fcmps with constants into llvm.is.fpclass.
   //
   // If we can represent a combined value test with one class call, we can
   // potentially eliminate 4-6 instructions. If we can represent a test with a
   // single fcmp with fneg and fabs, that's likely a better canonical form.
-  if (LHS->hasOneUse() && RHS->hasOneUse()) {
+  if (LHS.hasOneUse() && RHS.hasOneUse()) {
     auto [ClassValRHS, ClassMaskRHS] =
-        fcmpToClassTest(PredR, *RHS->getFunction(), RHS0, RHS1);
+        fcmpToClassTest(PredR, *RHS.OrigCmp_->getFunction(), RHS0, RHS1);
     if (ClassValRHS) {
       auto [ClassValLHS, ClassMaskLHS] =
-          fcmpToClassTest(PredL, *LHS->getFunction(), LHS0, LHS1);
+          fcmpToClassTest(PredL, *LHS.OrigCmp_->getFunction(), LHS0, LHS1);
       if (ClassValLHS == ClassValRHS) {
         unsigned CombinedMask = IsAnd ? (ClassMaskLHS & ClassMaskRHS)
                                       : (ClassMaskLHS | ClassMaskRHS);
         return Builder.CreateIntrinsic(
             Intrinsic::is_fpclass, {ClassValLHS->getType()},
             {ClassValLHS, Builder.getInt32(CombinedMask)});
       }
     }
if (Value *Cond = getSelectCondition(A, B, InvertFalseVal)) {
     return Builder.CreateBitCast(Select, OrigType);
   }
 
   return nullptr;
 }
 
 // (icmp eq X, C) | (icmp ult Other, (X - C)) -> (icmp ule Other, (X - (C + 1)))
 // (icmp ne X, C) & (icmp uge Other, (X - C)) -> (icmp ugt Other, (X - (C + 1)))
-static Value *foldAndOrOfICmpEqConstantAndICmp(ICmpInst *LHS, ICmpInst *RHS,
-                                               bool IsAnd, bool IsLogical,
-                                               IRBuilderBase &Builder) {
-  Value *LHS0 = LHS->getOperand(0);
-  Value *RHS0 = RHS->getOperand(0);
-  Value *RHS1 = RHS->getOperand(1);
+static Value *foldAndOrOfICmpEqConstantAndICmp(
+    InstCombinerImpl::ICmpComponents LHS, InstCombinerImpl::ICmpComponents RHS,
+    bool IsAnd, bool IsLogical, IRBuilderBase &Builder) {
+  Value *LHS0 = LHS.getOperand(0);
+  Value *RHS0 = RHS.getOperand(0);
+  Value *RHS1 = RHS.getOperand(1);
 
   ICmpInst::Predicate LPred =
-      IsAnd ? LHS->getInversePredicate() : LHS->getPredicate();
+      IsAnd ? LHS.getInversePredicate() : LHS.getPredicate();
   ICmpInst::Predicate RPred =
-      IsAnd ? RHS->getInversePredicate() : RHS->getPredicate();
+      IsAnd ? RHS.getInversePredicate() : RHS.getPredicate();
 
   const APInt *CInt;
   if (LPred != ICmpInst::ICMP_EQ ||
-      !match(LHS->getOperand(1), m_APIntAllowUndef(CInt)) ||
+      !match(LHS.getOperand(1), m_APIntAllowUndef(CInt)) ||
       !LHS0->getType()->isIntOrIntVectorTy() ||
-      !(LHS->hasOneUse() || RHS->hasOneUse()))
+      !(LHS.hasOneUse() || RHS.hasOneUse()))
     return nullptr;
 
   auto MatchRHSOp = [LHS0, CInt](const Value *RHSOp) {
     return match(RHSOp,
                  m_Add(m_Specific(LHS0), m_SpecificIntAllowUndef(-*CInt))) ||
            (CInt->isZero() && RHSOp == LHS0);
   };
 
return Builder.CreateICmp(
       IsAnd ? ICmpInst::ICMP_ULT : ICmpInst::ICMP_UGE,
       Builder.CreateSub(LHS0, ConstantInt::get(LHS0->getType(), *CInt + 1)),
       Other);
 }
 
 /// Fold (icmp)&(icmp) or (icmp)|(icmp) if possible.
 /// If IsLogical is true, then the and/or is in select form and the transform
 /// must be poison-safe.
-Value *InstCombinerImpl::foldAndOrOfICmps(ICmpInst *LHS, ICmpInst *RHS,
-                                          Instruction &I, bool IsAnd,
-                                          bool IsLogical) {
+Value *InstCombinerImpl::foldAndOrOfICmps(ICmpComponents LHS,
+                                          ICmpComponents RHS, Instruction &I,
+                                          bool IsAnd, bool IsLogical) {
   const SimplifyQuery Q = SQ.getWithInstruction(&I);
 
   // Fold (iszero(A & K1) | iszero(A & K2)) ->  (A & (K1 | K2)) != (K1 | K2)
   // Fold (!iszero(A & K1) & !iszero(A & K2)) ->  (A & (K1 | K2)) == (K1 | K2)
   // if K1 and K2 are a one-bit mask.
   if (Value *V = foldAndOrOfICmpsOfAndWithPow2(LHS, RHS, &I, IsAnd, IsLogical))
     return V;
 
-  ICmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
-  Value *LHS0 = LHS->getOperand(0), *RHS0 = RHS->getOperand(0);
-  Value *LHS1 = LHS->getOperand(1), *RHS1 = RHS->getOperand(1);
+  ICmpInst::Predicate PredL = LHS.getPredicate(), PredR = RHS.getPredicate();
+  Value *LHS0 = LHS.getOperand(0), *RHS0 = RHS.getOperand(0);
+  Value *LHS1 = LHS.getOperand(1), *RHS1 = RHS.getOperand(1);
   const APInt *LHSC = nullptr, *RHSC = nullptr;
   match(LHS1, m_APInt(LHSC));
   match(RHS1, m_APInt(RHSC));
 
   // (icmp1 A, B) | (icmp2 A, B) --> (icmp3 A, B)
   // (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B)
   if (predicatesFoldable(PredL, PredR)) {
     if (LHS0 == RHS1 && LHS1 == RHS0) {
       PredL = ICmpInst::getSwappedPredicate(PredL);
       std::swap(LHS0, LHS1);
     }
     if (LHS0 == RHS0 && LHS1 == RHS1) {
       unsigned Code = IsAnd ? getICmpCode(PredL) & getICmpCode(PredR)
                             : getICmpCode(PredL) | getICmpCode(PredR);
-      bool IsSigned = LHS->isSigned() || RHS->isSigned();
+      bool IsSigned = LHS.isSigned() || RHS.isSigned();
       return getNewICmpValue(Code, IsSigned, LHS0, LHS1, Builder);
     }
   }
 
   // handle (roughly):
   // (icmp ne (A & B), C) | (icmp ne (A & D), E)
   // (icmp eq (A & B), C) & (icmp eq (A & D), E)
   if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, IsAnd, IsLogical, Builder))
Value *InstCombinerImpl::foldAndOrOfICmps(ICmpComponents LHS,
   if (!LHSC || !RHSC)
     return nullptr;
 
   // (trunc x) == C1 & (and x, CA) == C2 -> (and x, CA|CMAX) == C1|C2
   // (trunc x) != C1 | (and x, CA) != C2 -> (and x, CA|CMAX) != C1|C2
   // where CMAX is the all ones value for the truncated type,
   // iff the lower bits of C2 and CA are zero.
   if (PredL == (IsAnd ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE) &&
-      PredL == PredR && LHS->hasOneUse() && RHS->hasOneUse()) {
+      PredL == PredR && LHS.hasOneUse() && RHS.hasOneUse()) {
     Value *V;
     const APInt *AndC, *SmallC = nullptr, *BigC = nullptr;
 
     // (trunc x) == C1 & (and x, CA) == C2
     // (and x, CA) == C2 & (trunc x) == C1
     if (match(RHS0, m_Trunc(m_Value(V))) &&
         match(LHS0, m_And(m_Specific(V), m_APInt(AndC)))) {
       SmallC = RHSC;
Value *InstCombinerImpl::foldAndOrOfICmps(ICmpComponents LHS,
   // Match naive pattern (and its inverted form) for checking if two values
   // share same sign. An example of the pattern:
   // (icmp slt (X & Y), 0) | (icmp sgt (X | Y), -1) -> (icmp sgt (X ^ Y), -1)
   // Inverted form (example):
   // (icmp slt (X | Y), 0) & (icmp sgt (X & Y), -1) -> (icmp slt (X ^ Y), 0)
   bool TrueIfSignedL, TrueIfSignedR;
   if (isSignBitCheck(PredL, *LHSC, TrueIfSignedL) &&
       isSignBitCheck(PredR, *RHSC, TrueIfSignedR) &&
-      (RHS->hasOneUse() || LHS->hasOneUse())) {
+      (RHS.hasOneUse() || LHS.hasOneUse())) {
     Value *X, *Y;
     if (IsAnd) {
       if ((TrueIfSignedL && !TrueIfSignedR &&
            match(LHS0, m_Or(m_Value(X), m_Value(Y))) &&
            match(RHS0, m_c_And(m_Specific(X), m_Specific(Y)))) ||
           (!TrueIfSignedL && TrueIfSignedR &&
            match(LHS0, m_And(m_Value(X), m_Value(Y))) &&
            match(RHS0, m_c_Or(m_Specific(X), m_Specific(Y))))) {

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

public:
   Instruction *visitSRem(BinaryOperator &I);
   Instruction *visitFRem(BinaryOperator &I);
   bool simplifyDivRemOfSelectWithZeroOp(BinaryOperator &I);
   Instruction *commonIRemTransforms(BinaryOperator &I);
   Instruction *commonIDivTransforms(BinaryOperator &I);
   Instruction *visitUDiv(BinaryOperator &I);
   Instruction *visitSDiv(BinaryOperator &I);
   Instruction *visitFDiv(BinaryOperator &I);
-  Value *simplifyRangeCheck(ICmpInst *Cmp0, ICmpInst *Cmp1, bool Inverted);
   Instruction *visitAnd(BinaryOperator &I);
   Instruction *visitOr(BinaryOperator &I);
   bool sinkNotIntoLogicalOp(Instruction &I);
   bool sinkNotIntoOtherHandOfLogicalOp(Instruction &I);
   Instruction *visitXor(BinaryOperator &I);
   Instruction *visitShl(BinaryOperator &I);
   Value *reassociateShiftAmtsOfTwoSameDirectionShifts(
       BinaryOperator *Sh0, const SimplifyQuery &SQ,
return llvm::computeKnownFPClass(Val, DL, Interested, Depth, &TLI, &AC,
                                      CtxI, &DT);
   }
 
   /// Check if fmul \p MulVal, +0.0 will yield +0.0 (or signed zero is
   /// ignorable).
   bool fmulByZeroIsZero(Value *MulVal, FastMathFlags FMF,
                         const Instruction *CtxI) const;
 
+  // Wrapper around icmp/fcmp instructions to be used in various folds to
+  // avoiding having to have to actual icmp/fcmp Value created.
+  // For use when the question of if we want to create a new cmp is a question
+  // of whether it will get folded.
+  template <typename CmpType> struct CmpComponents {
+    using PredType = typename CmpType::Predicate;
+    PredType Pred_;
+    Value *Op0_;
+    Value *Op1_;
+    CmpType *OrigCmp_;
+
+    bool hasOneUse() const { return OrigCmp_->hasOneUse(); }
+    bool isSigned() const { return CmpType::isSigned(Pred_); }
+
+    Type *getType() const { return OrigCmp_->getType(); }
+
+    Value *getOperand(unsigned Idx) const {
+      assert(Idx <= 1 && "Out of bounds operand");
+      return Idx == 0 ? Op0_ : Op1_;
+    }
+
+    PredType getPredicate() const { return Pred_; }
+
+    PredType getInversePredicate() const {
+      return CmpType::getInversePredicate(Pred_);
+    }
+
+    PredType getSwappedPredicate() const {
+      return CmpType::getSwappedPredicate(Pred_);
+    }
+
+    Value *getOrCreateValue(InstCombiner::BuilderTy &Builder) const {
+      if (Pred_ == OrigCmp_->getPredicate() &&
+          Op0_ == OrigCmp_->getOperand(0) && Op1_ == OrigCmp_->getOperand(1))
+        return OrigCmp_;
+      return Builder.CreateCmp(Pred_, Op0_, Op1_);
+    }
+
+    CmpComponents() = default;
+    CmpComponents(CmpType *Cmp)
+        : Pred_(Cmp->getPredicate()), Op0_(Cmp->getOperand(0)),
+          Op1_(Cmp->getOperand(1)), OrigCmp_(Cmp) {}
+  };
+
+  using FCmpComponents = CmpComponents<FCmpInst>;
+  using ICmpComponents = CmpComponents<ICmpInst>;
+
+  Value *simplifyRangeCheck(ICmpComponents Cmp0, ICmpComponents Cmp1,
+                            bool Inverted);
+
 private:
   bool annotateAnyAllocSite(CallBase &Call, const TargetLibraryInfo *TLI);
   bool isDesirableIntType(unsigned BitWidth) const;
   bool shouldChangeType(unsigned FromBitWidth, unsigned ToBitWidth) const;
   bool shouldChangeType(Type *From, Type *To) const;
   Value *dyn_castNegVal(Value *V) const;
 
   /// Classify whether a cast is worth optimizing.
private:
   /// Instruction::CastOps value for a cast that can replace the pair, casting
   /// CI1->getSrcTy() to CI2->getDstTy().
   ///
   /// \see CastInst::isEliminableCastPair
   Instruction::CastOps isEliminableCastPair(const CastInst *CI1,
                                             const CastInst *CI2);
   Value *simplifyIntToPtrRoundTripCast(Value *Val);
 
-  Value *foldAndOrOfICmps(ICmpInst *LHS, ICmpInst *RHS, Instruction &I,
-                          bool IsAnd, bool IsLogical = false);
+  Value *foldAndOrOfICmps(ICmpComponents LHS, ICmpComponents RHS,
+                          Instruction &I, bool IsAnd, bool IsLogical = false);
   Value *foldXorOfICmps(ICmpInst *LHS, ICmpInst *RHS, BinaryOperator &Xor);
 
-  Value *foldEqOfParts(ICmpInst *Cmp0, ICmpInst *Cmp1, bool IsAnd);
+  Value *foldEqOfParts(ICmpComponents Cmp0, ICmpComponents Cmp1, bool IsAnd);
 
-  Value *foldAndOrOfICmpsUsingRanges(ICmpInst *ICmp1, ICmpInst *ICmp2,
+  Value *foldAndOrOfICmpsUsingRanges(ICmpComponents ICmp1, ICmpComponents ICmp2,
                                      bool IsAnd);
 
   /// Optimize (fcmp)&(fcmp) or (fcmp)|(fcmp).
   /// NOTE: Unlike most of instcombine, this returns a Value which should
   /// already be inserted into the function.
-  Value *foldLogicOfFCmps(FCmpInst *LHS, FCmpInst *RHS, bool IsAnd,
+  Value *foldLogicOfFCmps(FCmpComponents LHS, FCmpComponents RHS, bool IsAnd,
                           bool IsLogicalSelect = false);
 
   Instruction *foldLogicOfIsFPClass(BinaryOperator &Operator, Value *LHS,
                                     Value *RHS);
 
   Instruction *
   canonicalizeConditionalNegationViaMathToSelect(BinaryOperator &i);
 
-  Value *foldAndOrOfICmpsOfAndWithPow2(ICmpInst *LHS, ICmpInst *RHS,
+  Value *foldAndOrOfICmpsOfAndWithPow2(ICmpComponents LHS, ICmpComponents RHS,
                                        Instruction *CxtI, bool IsAnd,
                                        bool IsLogical = false);
   Value *matchSelectFromAndOr(Value *A, Value *B, Value *C, Value *D,
                               bool InvertFalseVal = false);
   Value *getSelectCondition(Value *A, Value *B, bool ABIsTheSame);
 
   Instruction *foldLShrOverflowBit(BinaryOperator &I);
   Instruction *foldExtractOfOverflowIntrinsic(ExtractValueInst &EV);