[GuardWidening] Use freeze to widen using possible poison value.

[skatkov]

Summary

During the guard widening we can add a poison use in the first guard which
can result in undefined behavior which were not before due to this guard could
guards us from it.

To avoid this behavior we can use freeze instruction.

[fhahn]

llvm/test/Transforms/GuardWidening/basic.ll

368

It seems it would be sufficient to only freeze the final value?

[skatkov]

llvm/test/Transforms/GuardWidening/basic.ll

368

Thanks for noting that.

[nikic]

Does this actually need freeze, rather than just logical and instead of bitwise and?

[skatkov]

In D128155#3596981, @nikic wrote:

Does this actually need freeze, rather than just logical and instead of bitwise and?

Do we have logical and?

[nikic]

Logical and is select i1 %c1, i1 %c2, i1 false.

[reames]

In D128155#3598053, @nikic wrote:

Logical and is select i1 %c1, i1 %c2, i1 false.

Also, IRBuilder::CreateLogicalAnd

[skatkov]

I tend to re-write the patch and introduce the option to use freeze or logical and then choose the best one.
To have improved version of this patch for freeze and implement select solution I'll need to do some preparation work to know what condition comes from the widening guard (it should be first in logcal and and there is no need to freeze it) and what comes from other guard.
So, please be tuned.

Thank you, guys for suggestions.

[skatkov]

Please take a look the alternative solution with logical and: https://reviews.llvm.org/D128322

[skatkov]

I come up with this version of the solution.

Dear reviewers, I would appreciate the review.

[apilipenko]

Could you please give a brief outline of the approach?

[skatkov]

In D128155#3626453, @apilipenko wrote:

Could you please give a brief outline of the approach?

Guard Widening uses two main ways to wide the current guard.
The second one is just combine conditions of two guards and apply it to the first one.
For this case we just use c1 & freeze(c2) in case we cannot prove that c2 is not a poison.
If we prove that c2 is not a poison the result is just c1& c2.

The first case is more complex.
First, it parses the conditions of first guard (guard to wide) and second one.
In case all conditions are and operation of "range checks" it will merge them.
Range check is a condition of the form base + offset unsigned less then length.
For each condition, case, offset and length can be different but offset must be an integer constant.
I try to reduce the number of freeze usages, so during the parsing we detect some facts.
While parsing the first guard we consider that all values do not require freeze due to if base or length were poison than
we had a UB(guard on poison value) in the original program so we do not care.
Parsing the second guard we conservatively suggest that freeze will be needed due to we will hoist the condition which potentially
may be a poison at the point of the first guard.
Also of we meet freeze instruction we go through it in parsing but consider that everything down require a freeze even if it comes from
the first guard (most probably it is a result of previous guard widening of the simple form).

Later optimization consider all Bi + OFFi < Li and split them into groups where Bi and Li are equal.
For each group it does the following:
if the size of the group is less then 3 then do not combine this group.
Otherwise if the OFFi from this group does not satisfy conditions required for this optimization Do not combine anything - just bailout.
Finally for this group combine all range checks and leave only B + OFFmin < L & B + OFFmax < L.
It is possible that both conditions comes from the second guard and will be hoisted so we need to freeze B and L.
However if B or L used in condition came from the first guard we can avoid freezing due to the same reason - we had UB in the original
program if B or L were poison.

After all groups are processed we combine all checks with arithmetic and operation but freeze those elements which require this.

I hope it helps.
the first guard

[skatkov]

in favor of https://reviews.llvm.org/D146699

llvm/lib/Transforms/Scalar/GuardWidening.cpp

class GuardWideningImpl {
   bool widenCondCommon(Value *Cond0, Value *Cond1, Instruction *InsertPt,
                        Value *&Result, bool InvertCondition);
 
   /// Represents a range check of the form \c Base + \c Offset u< \c Length,
   /// with the constraint that \c Length is not negative.  \c CheckInst is the
   /// pre-existing instruction in the IR that computes the result of this range
   /// check.
   class RangeCheck {
-    const Value *Base;
-    const ConstantInt *Offset;
-    const Value *Length;
+    Value *Base;
+    ConstantInt *Offset;
+    Value *Length;
     ICmpInst *CheckInst;
+    bool MayNeedFreeze;
+    bool BaseNeedFreeze;
+    bool LengthNeedFreeze;
+    bool NeedCleanOfPoisonFlags;
 
   public:
-    explicit RangeCheck(const Value *Base, const ConstantInt *Offset,
-                        const Value *Length, ICmpInst *CheckInst)
-        : Base(Base), Offset(Offset), Length(Length), CheckInst(CheckInst) {}
+    explicit RangeCheck(Value *Base, ConstantInt *Offset, Value *Length,
+                        ICmpInst *CheckInst, bool MayNeedFreeze)
+        : Base(Base), Offset(Offset), Length(Length), CheckInst(CheckInst),
+          MayNeedFreeze(MayNeedFreeze), BaseNeedFreeze(false),
+          LengthNeedFreeze(false), NeedCleanOfPoisonFlags(false) {}
+
+    void setBase(Value *NewBase) { Base = NewBase; }
+    void setOffset(ConstantInt *NewOffset) { Offset = NewOffset; }
+    void setBaseNeedFreeze() { BaseNeedFreeze = true; }
+    void setLengthNeedFreeze() { LengthNeedFreeze = true; }
+    void setNeedCleanOfPoisonFlags() { NeedCleanOfPoisonFlags = true; }
+    void setMayNeedFreeze() { MayNeedFreeze = true; }
 
-    void setBase(const Value *NewBase) { Base = NewBase; }
-    void setOffset(const ConstantInt *NewOffset) { Offset = NewOffset; }
-
-    const Value *getBase() const { return Base; }
-    const ConstantInt *getOffset() const { return Offset; }
+    Value *getBase() const { return Base; }
+    ConstantInt *getOffset() const { return Offset; }
     const APInt &getOffsetValue() const { return getOffset()->getValue(); }
-    const Value *getLength() const { return Length; };
+    Value *getLength() const {
+      return Length;
+    };
     ICmpInst *getCheckInst() const { return CheckInst; }
+    bool getMayNeedFreeze() const { return MayNeedFreeze; }
+    bool getBaseNeedFreeze() const { return BaseNeedFreeze; }
+    bool getLengthNeedFreeze() const { return LengthNeedFreeze; }
+    bool getNeedCleanOfPoisonFlags() const { return NeedCleanOfPoisonFlags; }
 
     void print(raw_ostream &OS, bool PrintTypes = false) {
       OS << "Base: ";
       Base->printAsOperand(OS, PrintTypes);
       OS << " Offset: ";
       Offset->printAsOperand(OS, PrintTypes);
       OS << " Length: ";
       Length->printAsOperand(OS, PrintTypes);
     }
 
     LLVM_DUMP_METHOD void dump() {
       print(dbgs());
       dbgs() << "\n";
     }
   };
 
   /// Parse \p CheckCond into a conjunction (logical-and) of range checks; and
   /// append them to \p Checks.  Returns true on success, may clobber \c Checks
   /// on failure.
-  bool parseRangeChecks(Value *CheckCond, SmallVectorImpl<RangeCheck> &Checks) {
+  bool parseRangeChecks(Value *CheckCond, SmallVectorImpl<RangeCheck> &Checks,
+                        DenseMap<Value *, Value *> &ValueToFreeze,
+                        bool MayNeedFreeze) {
     SmallPtrSet<const Value *, 8> Visited;
-    return parseRangeChecks(CheckCond, Checks, Visited);
+    return parseRangeChecks(CheckCond, Checks, Visited, ValueToFreeze,
+                            MayNeedFreeze);
   }
 
   bool parseRangeChecks(Value *CheckCond, SmallVectorImpl<RangeCheck> &Checks,
-                        SmallPtrSetImpl<const Value *> &Visited);
+                        SmallPtrSetImpl<const Value *> &Visited,
+                        DenseMap<Value *, Value *> &ValueToFreeze,
+                        bool MayNeedFreeze);
 
   /// Combine the checks in \p Checks into a smaller set of checks and append
   /// them into \p CombinedChecks.  Return true on success (i.e. all of checks
   /// in \p Checks were combined into \p CombinedChecks).  Clobbers \p Checks
   /// and \p CombinedChecks on success and on failure.
   bool combineRangeChecks(SmallVectorImpl<RangeCheck> &Checks,
                           SmallVectorImpl<RangeCheck> &CombinedChecks) const;
 
void GuardWideningImpl::makeAvailableAt(Value *V, Instruction *Loc) const {
 
   assert(isSafeToSpeculativelyExecute(Inst, Loc, &DT) &&
          !Inst->mayReadFromMemory() && "Should've checked with isAvailableAt!");
 
   for (Value *Op : Inst->operands())
     makeAvailableAt(Op, Loc);
 
   Inst->moveBefore(Loc);
-  // If we moved instruction before guard we must clean poison generating flags.
-  Inst->dropPoisonGeneratingFlags();
 }
 
 bool GuardWideningImpl::widenCondCommon(Value *Cond0, Value *Cond1,
                                         Instruction *InsertPt, Value *&Result,
                                         bool InvertCondition) {
   using namespace llvm::PatternMatch;
 
   {
if (match(Cond0, m_ICmp(Pred0, m_Value(LHS), m_ConstantInt(RHS0))) &&
           return true;
         }
       }
     }
   }
 
   {
     SmallVector<GuardWideningImpl::RangeCheck, 4> Checks, CombinedChecks;
+    DenseMap<Value *, Value *> ValueToFreeze;
+    auto GetValue = [&](Value *V, bool NeedToFreeze) {
+      makeAvailableAt(V, InsertPt);
+      if (!NeedToFreeze)
+        return V;
+      auto It = ValueToFreeze.find(V);
+      if (It != ValueToFreeze.end()) {
+        V = It->second;
+        makeAvailableAt(V, InsertPt);
+        return V;
+      }
+      Value *Freeze = V;
+      if (!isGuaranteedNotToBePoison(V, nullptr, InsertPt, &DT))
+        Freeze = new FreezeInst(V, "gw.freeze", InsertPt);
+      ValueToFreeze[V] = Freeze;
+      return Freeze;
+    };
     // TODO: Support InvertCondition case?
     if (!InvertCondition &&
-        parseRangeChecks(Cond0, Checks) && parseRangeChecks(Cond1, Checks) &&
+        parseRangeChecks(Cond0, Checks, ValueToFreeze, false) &&
+        parseRangeChecks(Cond1, Checks, ValueToFreeze, true) &&
         combineRangeChecks(Checks, CombinedChecks)) {
       if (InsertPt) {
         Result = nullptr;
         for (auto &RC : CombinedChecks) {
-          makeAvailableAt(RC.getCheckInst(), InsertPt);
+          // Prepare candidate first.
+          Value *Condition = nullptr;
+          if (RC.getNeedCleanOfPoisonFlags()) {
+            // We need to generate
+            // freeze(base) + offset unsigned less than freeze(L).
+            Value *Base = GetValue(RC.getBase(), RC.getMayNeedFreeze() &&
+                                                     RC.getBaseNeedFreeze());
+            Value *BaseAndOffset =
+                BinaryOperator::CreateAdd(Base, RC.getOffset(), "", InsertPt);
+            Value *Length =
+                GetValue(RC.getLength(),
+                         RC.getMayNeedFreeze() && RC.getLengthNeedFreeze());
+            Condition = new ICmpInst(InsertPt, CmpInst::Predicate::ICMP_ULT,
+                                     BaseAndOffset, Length, "");
+          } else {
+            // Ok, this range check comes without any combining.
+            // It may be from guard we are widening or from other guard.
+            // In the second case we need to freeze it if it can be poison.
+            Condition = GetValue(RC.getCheckInst(), RC.getMayNeedFreeze());
+          }
           if (Result)
-            Result = BinaryOperator::CreateAnd(RC.getCheckInst(), Result, "",
-                                               InsertPt);
+            Result = BinaryOperator::CreateAnd(Result, Condition, "", InsertPt);
           else
-            Result = RC.getCheckInst();
+            Result = Condition;
         }
+
         assert(Result && "Failed to find result value");
         Result->setName("wide.chk");
       }
       return true;
     }
   }
 
   // Base case -- just logical-and the two conditions together.
 
   if (InsertPt) {
     makeAvailableAt(Cond0, InsertPt);
     makeAvailableAt(Cond1, InsertPt);
     if (InvertCondition)
       Cond1 = BinaryOperator::CreateNot(Cond1, "inverted", InsertPt);
+    if (!isGuaranteedNotToBePoison(Cond1, nullptr, InsertPt, &DT))
+      Cond1 = new FreezeInst(Cond1, "gw.freeze", InsertPt);
     Result = BinaryOperator::CreateAnd(Cond0, Cond1, "wide.chk", InsertPt);
   }
 
   // We were not able to compute Cond0 AND Cond1 for the price of one.
   return false;
 }
 
 bool GuardWideningImpl::parseRangeChecks(
     Value *CheckCond, SmallVectorImpl<GuardWideningImpl::RangeCheck> &Checks,
-    SmallPtrSetImpl<const Value *> &Visited) {
+    SmallPtrSetImpl<const Value *> &Visited,
+    DenseMap<Value *, Value *> &ValueToFreeze, bool MayNeedFreeze) {
   if (!Visited.insert(CheckCond).second)
     return true;
 
+  if (auto *FreezeCheckInst = dyn_cast<FreezeInst>(CheckCond)) {
+    CheckCond = FreezeCheckInst->getOperand(0);
+    ValueToFreeze[CheckCond] = FreezeCheckInst;
+    MayNeedFreeze = true;
+  }
+
   using namespace llvm::PatternMatch;
 
   {
     Value *AndLHS, *AndRHS;
     if (match(CheckCond, m_And(m_Value(AndLHS), m_Value(AndRHS))))
-      return parseRangeChecks(AndLHS, Checks) &&
-             parseRangeChecks(AndRHS, Checks);
+      return parseRangeChecks(AndLHS, Checks, ValueToFreeze, MayNeedFreeze) &&
+             parseRangeChecks(AndRHS, Checks, ValueToFreeze, MayNeedFreeze);
   }
 
   auto *IC = dyn_cast<ICmpInst>(CheckCond);
   if (!IC || !IC->getOperand(0)->getType()->isIntegerTy() ||
       (IC->getPredicate() != ICmpInst::ICMP_ULT &&
        IC->getPredicate() != ICmpInst::ICMP_UGT))
     return false;
 
-  const Value *CmpLHS = IC->getOperand(0), *CmpRHS = IC->getOperand(1);
+  Value *CmpLHS = IC->getOperand(0), *CmpRHS = IC->getOperand(1);
   if (IC->getPredicate() == ICmpInst::ICMP_UGT)
     std::swap(CmpLHS, CmpRHS);
 
   auto &DL = IC->getModule()->getDataLayout();
 
+  if (auto *FreezeBase = dyn_cast<FreezeInst>(CmpLHS)) {
+    CmpLHS = FreezeBase->getOperand(0);
+    ValueToFreeze[CmpLHS] = FreezeBase;
+    MayNeedFreeze = true;
+  }
+  if (auto *FreezeLength = dyn_cast<FreezeInst>(CmpRHS)) {
+    CmpRHS = FreezeLength->getOperand(0);
+    ValueToFreeze[CmpRHS] = FreezeLength;
+    MayNeedFreeze = true;
+  }
   GuardWideningImpl::RangeCheck Check(
       CmpLHS, cast<ConstantInt>(ConstantInt::getNullValue(CmpRHS->getType())),
-      CmpRHS, IC);
+      CmpRHS, IC, MayNeedFreeze);
 
   if (!isKnownNonNegative(Check.getLength(), DL))
     return false;
 
   // What we have in \c Check now is a correct interpretation of \p CheckCond.
   // Try to see if we can move some constant offsets into the \c Offset field.
 
   bool Changed;
   auto &Ctx = CheckCond->getContext();
 
   do {
     Value *OpLHS;
     ConstantInt *OpRHS;
     Changed = false;
 
 #ifndef NDEBUG
     auto *BaseInst = dyn_cast<Instruction>(Check.getBase());
     assert((!BaseInst || DT.isReachableFromEntry(BaseInst->getParent())) &&
            "Unreachable instruction?");
 #endif
 
     if (match(Check.getBase(), m_Add(m_Value(OpLHS), m_ConstantInt(OpRHS)))) {
+      if (auto *FreezeBase = dyn_cast<FreezeInst>(OpLHS)) {
+        OpLHS = FreezeBase->getOperand(0);
+        ValueToFreeze[OpLHS] = FreezeBase;
+        Check.setMayNeedFreeze();
+      }
       Check.setBase(OpLHS);
       APInt NewOffset = Check.getOffsetValue() + OpRHS->getValue();
       Check.setOffset(ConstantInt::get(Ctx, NewOffset));
       Changed = true;
     } else if (match(Check.getBase(),
                      m_Or(m_Value(OpLHS), m_ConstantInt(OpRHS)))) {
       KnownBits Known = computeKnownBits(OpLHS, DL);
       if ((OpRHS->getValue() & Known.Zero) == OpRHS->getValue()) {
+        if (auto *FreezeBase = dyn_cast<FreezeInst>(OpLHS)) {
+          OpLHS = FreezeBase->getOperand(0);
+          ValueToFreeze[OpLHS] = FreezeBase;
+          Check.setMayNeedFreeze();
+        }
         Check.setBase(OpLHS);
         APInt NewOffset = Check.getOffsetValue() + OpRHS->getValue();
         Check.setOffset(ConstantInt::get(Ctx, NewOffset));
         Changed = true;
       }
     }
   } while (Changed);
 
   Checks.push_back(Check);
   return true;
 }
 
 bool GuardWideningImpl::combineRangeChecks(
     SmallVectorImpl<GuardWideningImpl::RangeCheck> &Checks,
     SmallVectorImpl<GuardWideningImpl::RangeCheck> &RangeChecksOut) const {
   unsigned OldCount = Checks.size();
+  // Collect all Bases and Length from the guard we are widening as
+  // they do not need freeze due to if they are poison we would have UB in the
+  // original program.
+  SmallPtrSet<const Value *, 4> NotNeedFreeze;
+  for (auto &RC : Checks) {
+    if (!RC.getMayNeedFreeze()) {
+      NotNeedFreeze.insert(RC.getBase());
+      NotNeedFreeze.insert(RC.getLength());
+    }
+  }
   while (!Checks.empty()) {
     // Pick all of the range checks with a specific base and length, and try to
     // merge them.
     const Value *CurrentBase = Checks.front().getBase();
     const Value *CurrentLength = Checks.front().getLength();
 
     SmallVector<GuardWideningImpl::RangeCheck, 3> CurrentChecks;
 
while (!Checks.empty()) {
     // range by definition, and the latter case is impossible:
     //
     //   0-----I+k_f---I+k_0----L---INT_MAX,INT_MIN------------------(-1)
     //   xxxxxx             xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
     //
     // For Chk_0 to succeed, we'd have to have k_f-k_0 (the range highlighted
     // with 'x' above) to be at least >u INT_MIN.
 
+    // Well, we need to deal with possible poison of range checks now.
+    // All range checks of the form Base + Offset.
+    if (!NotNeedFreeze.count(CurrentChecks.front().getBase())) {
+      CurrentChecks.front().setBaseNeedFreeze();
+      CurrentChecks.back().setBaseNeedFreeze();
+    }
+    if (!NotNeedFreeze.count(CurrentChecks.front().getLength())) {
+      CurrentChecks.front().setLengthNeedFreeze();
+      CurrentChecks.back().setLengthNeedFreeze();
+    }
+    CurrentChecks.front().setNeedCleanOfPoisonFlags();
+    CurrentChecks.back().setNeedCleanOfPoisonFlags();
+
     RangeChecksOut.emplace_back(CurrentChecks.front());
     RangeChecksOut.emplace_back(CurrentChecks.back());
   }
 
   assert(RangeChecksOut.size() <= OldCount && "We pessimized!");
   return RangeChecksOut.size() != OldCount;
 }
 

llvm/test/Transforms/GuardWidening/basic-loop.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes="loop-mssa(guard-widening)" -verify-memoryssa < %s | FileCheck %s
 
 declare void @llvm.experimental.guard(i1,...)
 
 @G = external global i32
 
 ; Show that we can widen into early checks within a loop, and in the process
 ; expose optimization oppurtunities.
 define void @widen_within_loop(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
 ; CHECK-LABEL: @widen_within_loop(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    store i32 0, i32* @G, align 4
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[WIDE_CHK]], [[COND_2:%.*]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK1]]) [ "deopt"(i32 0) ]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[GW_FREEZE1:%.*]] = freeze i1 [[COND_2:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[WIDE_CHK]], [[GW_FREEZE1]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"(i32 0) ]
 ; CHECK-NEXT:    store i32 1, i32* @G, align 4
 ; CHECK-NEXT:    store i32 2, i32* @G, align 4
 ; CHECK-NEXT:    store i32 3, i32* @G, align 4
 ; CHECK-NEXT:    br label [[LOOP]]
 ;
 entry:
   br label %loop
 
 loop:
   store i32 0, i32* @G
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"(i32 0) ]
   store i32 1, i32* @G
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"(i32 1) ]
   store i32 2, i32* @G
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"(i32 2) ]
   store i32 3, i32* @G
   br label %loop
 }
 
 define void @widen_into_preheader(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
 ; CHECK-LABEL: @widen_into_preheader(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 0, i32* @G, align 4
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[WIDE_CHK]], [[COND_2:%.*]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK1]]) [ "deopt"(i32 0) ]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[GW_FREEZE1:%.*]] = freeze i1 [[COND_2:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[WIDE_CHK]], [[GW_FREEZE1]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"(i32 0) ]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    store i32 1, i32* @G, align 4
 ; CHECK-NEXT:    store i32 2, i32* @G, align 4
 ; CHECK-NEXT:    store i32 3, i32* @G, align 4
 ; CHECK-NEXT:    br label [[LOOP]]
 ;
 entry:

 exit:
   ret void
 }
 
 define void @widen_over_common_exit_to_ph(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
 ; CHECK-LABEL: @widen_over_common_exit_to_ph(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    store i32 0, i32* @G, align 4
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_2:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_2:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"(i32 0) ]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    store i32 1, i32* @G, align 4
 ; CHECK-NEXT:    br i1 [[COND_1:%.*]], label [[BACKEDGE:%.*]], label [[EXIT:%.*]]
 ; CHECK:       backedge:
 ; CHECK-NEXT:    store i32 2, i32* @G, align 4
 ; CHECK-NEXT:    store i32 3, i32* @G, align 4

llvm/test/Transforms/GuardWidening/basic.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -guard-widening < %s        | FileCheck %s
 ; RUN: opt -S -passes=guard-widening < %s | FileCheck %s
 
 declare void @llvm.experimental.guard(i1,...)
 
 ; Basic test case: we wide the first check to check both the
 ; conditions.
 define void @f_0(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_0(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 }
 
 ; Same as @f_0, but with using a more general notion of postdominance.
 define void @f_1(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
 ; CHECK:       left:
 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       right:
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
 ; CHECK-NEXT:    ret void

 
 ; Like @f_1, but we have some code we need to hoist before we can
 ; widen a dominanting check.
 define void @f_2(i32 %a, i32 %b) {
 ; CHECK-LABEL: @f_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
 ; CHECK:       left:
 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       right:
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
 ; CHECK-NEXT:    ret void

 ; But hoisting out of control flow is fine if it makes a loop computed
 ; condition loop invariant.  This behavior may require some tuning in
 ; the future.
 define void @f_4(i32 %a, i32 %b) {
 ; CHECK-LABEL: @f_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    br i1 undef, label [[LOOP:%.*]], label [[LEAVE:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    br i1 undef, label [[LOOP]], label [[LEAVE]]
 ; CHECK:       leave:
 ; CHECK-NEXT:    ret void
 ;
 entry:

 
 ; All else equal, we try to widen the earliest guard we can.  This
 ; heuristic can use some tuning.
 define void @f_7(i32 %a, i1* %cond_buf) {
 ; CHECK-LABEL: @f_7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_1:%.*]] = load volatile i1, i1* [[COND_BUF:%.*]], align 1
 ; CHECK-NEXT:    [[COND_3:%.*]] = icmp ult i32 [[A:%.*]], 7
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_1]], [[COND_3]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_3]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_1]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[COND_2:%.*]] = load volatile i1, i1* [[COND_BUF]], align 1
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_2]]) [ "deopt"() ]
 ; CHECK-NEXT:    br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
 ; CHECK:       left:
 ; CHECK-NEXT:    br label [[LEFT]]
 ; CHECK:       right:
 ; CHECK-NEXT:    ret void

 ; CHECK-LABEL: @f_8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_1:%.*]]) [ "deopt"() ]
 ; CHECK-NEXT:    br i1 undef, label [[LOOP]], label [[LEAVE:%.*]]
 ; CHECK:       leave:
 ; CHECK-NEXT:    [[COND_3:%.*]] = icmp ult i32 [[A:%.*]], 7
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_2:%.*]], [[COND_3]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_3]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_2:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    br i1 undef, label [[LOOP2:%.*]], label [[LEAVE2:%.*]]
 ; CHECK:       loop2:
 ; CHECK-NEXT:    br label [[LOOP2]]
 ; CHECK:       leave2:
 ; CHECK-NEXT:    ret void
 ;
 entry:

 
 ; With guards in loops, we're okay hoisting out the guard into the
 ; containing loop.
 define void @f_11(i32 %a, i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_11(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[INNER:%.*]]
 ; CHECK:       inner:
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    br i1 undef, label [[INNER]], label [[OUTER:%.*]]
 ; CHECK:       outer:
 ; CHECK-NEXT:    br label [[INNER]]
 ;
 entry:
   br label %inner
 
 inner:
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %inner, label %outer
 
 outer:
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   br label %inner
 }
 
 ; Checks that we are adequately guarded against exponential-time
 ; behavior when hoisting code.
 define void @f_12(i32 %a0) {
 ; CHECK-LABEL: @f_12(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A1:%.*]] = mul i32 [[A0:%.*]], [[A0]]
 ; CHECK-NEXT:    [[A2:%.*]] = mul i32 [[A1]], [[A1]]
 ; CHECK-NEXT:    [[A3:%.*]] = mul i32 [[A2]], [[A2]]
 ; CHECK-NEXT:    [[A4:%.*]] = mul i32 [[A3]], [[A3]]
 ; CHECK-NEXT:    [[A5:%.*]] = mul i32 [[A4]], [[A4]]
 ; CHECK-NEXT:    [[A6:%.*]] = mul i32 [[A5]], [[A5]]
 ; CHECK-NEXT:    [[A7:%.*]] = mul i32 [[A6]], [[A6]]
 ; CHECK-NEXT:    [[A8:%.*]] = mul i32 [[A7]], [[A7]]
 ; CHECK-NEXT:    [[A9:%.*]] = mul i32 [[A8]], [[A8]]

 ; CHECK-NEXT:    [[A24:%.*]] = mul i32 [[A23]], [[A23]]
 ; CHECK-NEXT:    [[A25:%.*]] = mul i32 [[A24]], [[A24]]
 ; CHECK-NEXT:    [[A26:%.*]] = mul i32 [[A25]], [[A25]]
 ; CHECK-NEXT:    [[A27:%.*]] = mul i32 [[A26]], [[A26]]
 ; CHECK-NEXT:    [[A28:%.*]] = mul i32 [[A27]], [[A27]]
 ; CHECK-NEXT:    [[A29:%.*]] = mul i32 [[A28]], [[A28]]
 ; CHECK-NEXT:    [[A30:%.*]] = mul i32 [[A29]], [[A29]]
 ; CHECK-NEXT:    [[COND:%.*]] = trunc i32 [[A30]] to i1
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 true, [[COND]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 true, [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 
 ; Eliding the earlier 29 multiplications for brevity
 
 entry:
   call void(i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ]

llvm/test/Transforms/GuardWidening/basic_widenable_condition_guards.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -guard-widening-widen-branch-guards=true -guard-widening < %s        | FileCheck %s
 ; RUN: opt -S -guard-widening-widen-branch-guards=true -passes=guard-widening < %s | FileCheck %s
 
 ; Basic test case: we wide the first check to check both the
 ; conditions.
 define void @f_0(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0:![0-9]+]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND_1]], [[WIDENABLE_COND3]]
guarded1:                                         ; preds = %guarded
   ret void
 }
 
 ; Same as @f_0, but with using a more general notion of postdominance.
 define void @f_1(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
 ; CHECK:       left:

 ; Like @f_1, but we have some code we need to hoist before we can
 ; widen a dominanting check.
 define void @f_2(i32 %a, i32 %b) {
 ; CHECK-LABEL: @f_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
 ; CHECK:       left:

 ; condition loop invariant.  This behavior may require some tuning in
 ; the future.
 define void @f_4(i32 %a, i32 %b) {
 ; CHECK-LABEL: @f_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    br i1 undef, label [[LOOP:%.*]], label [[LEAVE:%.*]]
 ; CHECK:       loop:

 ; All else equal, we try to widen the earliest guard we can.  This
 ; heuristic can use some tuning.
 define void @f_7(i32 %a, i1* %cond_buf) {
 ; CHECK-LABEL: @f_7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_1:%.*]] = load volatile i1, i1* [[COND_BUF:%.*]], align 1
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[COND_3:%.*]] = icmp ult i32 [[A:%.*]], 7
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_1]], [[COND_3]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_3]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_1]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    [[COND_2:%.*]] = load volatile i1, i1* [[COND_BUF]], align 1
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()

 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    br i1 undef, label [[LOOP]], label [[LEAVE:%.*]]
 ; CHECK:       leave:
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[COND_3:%.*]] = icmp ult i32 [[A:%.*]], 7
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_2:%.*]], [[COND_3]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_3]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_2:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND3]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt2:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded1:
 ; CHECK-NEXT:    br i1 undef, label [[LOOP2:%.*]], label [[LEAVE2:%.*]]
 ; CHECK:       loop2:

 ; With guards in loops, we're okay hoisting out the guard into the
 ; containing loop.
 define void @f_11(i32 %a, i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_11(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[OUTER_HEADER:%.*]]
 ; CHECK:       outer_header:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    br label [[INNER:%.*]]
 ; CHECK:       inner:

 ; CHECK-NEXT:    [[A24:%.*]] = mul i32 [[A23]], [[A23]]
 ; CHECK-NEXT:    [[A25:%.*]] = mul i32 [[A24]], [[A24]]
 ; CHECK-NEXT:    [[A26:%.*]] = mul i32 [[A25]], [[A25]]
 ; CHECK-NEXT:    [[A27:%.*]] = mul i32 [[A26]], [[A26]]
 ; CHECK-NEXT:    [[A28:%.*]] = mul i32 [[A27]], [[A27]]
 ; CHECK-NEXT:    [[A29:%.*]] = mul i32 [[A28]], [[A28]]
 ; CHECK-NEXT:    [[A30:%.*]] = mul i32 [[A29]], [[A29]]
 ; CHECK-NEXT:    [[COND:%.*]] = trunc i32 [[A30]] to i1
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 true, [[COND]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 true, [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND]], [[WIDENABLE_COND3]]
guarded1:                                         ; preds = %guarded
   ret void
 }
 
 
 define void @swapped_wb(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @swapped_wb(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDENABLE_COND]], [[WIDE_CHK]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND_1]], [[WIDENABLE_COND3]]

 guarded1:                                         ; preds = %guarded
   ret void
 }
 
 define void @trivial_wb(i1 %cond_0) {
 ; CHECK-LABEL: @trivial_wb(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 true, [[COND_0:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_0:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 true, [[GW_FREEZE]]
 ; CHECK-NEXT:    [[TMP0:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[TMP0]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND_0]], [[WIDENABLE_COND3]]

llvm/test/Transforms/GuardWidening/loop-schedule.ll

 
 declare void @llvm.experimental.guard(i1,...)
 
 define void @iter(i32 %a, i32 %b, i1* %c_p) {
 ; CHECK-LABEL: @iter(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[CND:%.*]] = load i1, i1* [[C_P:%.*]], align 1
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    br i1 [[CND]], label [[LOOP]], label [[LEAVE_LOOPEXIT:%.*]]
 ; CHECK:       leave.loopexit:
 ; CHECK-NEXT:    br label [[LEAVE:%.*]]
 ; CHECK:       leave:
leave:                                            ; preds = %leave.loopexit, %entry
   ret void
 }
 
 define void @within_loop(i32 %a, i32 %b, i1* %c_p) {
 ; CHECK-LABEL: @within_loop(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[CND:%.*]] = load i1, i1* [[C_P:%.*]], align 1
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    br i1 [[CND]], label [[LOOP]], label [[LEAVE_LOOPEXIT:%.*]]
 ; CHECK:       leave.loopexit:
 ; CHECK-NEXT:    br label [[LEAVE:%.*]]
 ; CHECK:       leave:

llvm/test/Transforms/GuardWidening/mixed_guards.ll

 
 ; Function Attrs: inaccessiblememonly nounwind
 declare i1 @llvm.experimental.widenable.condition() #0
 
 ; Widen condition of intrinsic guard with a condition from widenable branch.
 define void @test_01(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @test_01(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND_1]], [[WIDENABLE_COND3]]
 ; CHECK-NEXT:    br i1 true, label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof [[PROF0:![0-9]+]]
 ; CHECK:       deopt2:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded1:
guarded1:                                         ; preds = %guarded
   ret void
 }
 
 ; Widen condition of widenable condition guard with a condition from intrinsic.
 define void @test_02(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @test_02(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_1:%.*]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
 ; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded:
 ; CHECK-NEXT:    ret void
 ;

llvm/test/Transforms/GuardWidening/posion.ll

 ; are enough to cover c1 and c5, so it ends up with guard of c3 && c4
 ; while both of them are poison at entry. This is a bug.
 
 define void @combine_range_checks(i32 %x) {
 ; CHECK-LABEL: @combine_range_checks(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[X2:%.*]] = add i32 [[X:%.*]], 0
 ; CHECK-NEXT:    [[C2:%.*]] = icmp ult i32 [[X2]], 200
-; CHECK-NEXT:    [[X3:%.*]] = add nuw nsw i32 [[X]], 3
-; CHECK-NEXT:    [[C3:%.*]] = icmp ult i32 [[X3]], 100
-; CHECK-NEXT:    [[X4:%.*]] = add nuw nsw i32 [[X]], 20
-; CHECK-NEXT:    [[C4:%.*]] = icmp ult i32 [[X4]], 100
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[C4]], [[C3]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], 100
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 20
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], 100
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP1]], [[TMP3]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"(i64 1) ]
 ; CHECK-NEXT:    br i1 [[C2]], label [[OK:%.*]], label [[OUT:%.*]]
 ; CHECK:       ok:
 ; CHECK-NEXT:    br label [[OUT]]
 ; CHECK:       out:
 ; CHECK-NEXT:    ret void
 ;
 entry:

 ; go to deoptimization. But after guard widening freeze of c3 and c4 may return
 ; true due to c3 and c4 are poisons and we pass guard executing side effect store
 ; which never been executed in original program.
 define void @combine_range_checks_with_side_effect(i32 %x, i32* %p) {
 ; CHECK-LABEL: @combine_range_checks_with_side_effect(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[X2:%.*]] = add i32 [[X:%.*]], 0
 ; CHECK-NEXT:    [[C2:%.*]] = icmp ult i32 [[X2]], 200
-; CHECK-NEXT:    [[X3:%.*]] = add nuw nsw i32 [[X]], 3
-; CHECK-NEXT:    [[C3:%.*]] = icmp ult i32 [[X3]], 100
-; CHECK-NEXT:    [[X4:%.*]] = add nuw nsw i32 [[X]], 20
-; CHECK-NEXT:    [[C4:%.*]] = icmp ult i32 [[X4]], 100
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[C4]], [[C3]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], 100
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 20
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], 100
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP1]], [[TMP3]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"(i64 1) ]
 ; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    br i1 [[C2]], label [[OK:%.*]], label [[OUT:%.*]]
 ; CHECK:       ok:
 ; CHECK-NEXT:    br label [[OUT]]
 ; CHECK:       out:
 ; CHECK-NEXT:    ret void
 ;

 ; %b.shift and %cond_2 are poisons and after guard widening it leads to UB
 ; for both arithmetic and logcal and.
 define void @simple_case(i32 %a, i32 %b, i1 %cnd) {
 ; CHECK-LABEL: @simple_case(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[B_SHIFT:%.*]] = add nuw nsw i32 [[B:%.*]], 5
 ; CHECK-NEXT:    [[COND_2:%.*]] = icmp ult i32 [[B_SHIFT]], 10
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_2]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[COND_2]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B]], 10
 ; CHECK-NEXT:    br i1 [[COND_1]], label [[OK:%.*]], label [[LEAVE_LOOPEXIT:%.*]]
 ; CHECK:       ok:
 ; CHECK-NEXT:    br i1 [[CND:%.*]], label [[LOOP]], label [[LEAVE_LOOPEXIT]]
 ; CHECK:       leave.loopexit:
ok:
   br i1 %cnd, label %loop, label %leave.loopexit
 
 leave.loopexit:
   br label %leave
 
 leave:
   ret void
 }
+
+; The case checks that base needs a freeze.
+define void @combine_range_checks_base_need_freeze(i32 %y, i32 %x, i32* %p) {
+; CHECK-LABEL: @combine_range_checks_base_need_freeze(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[X2:%.*]] = add i32 [[X:%.*]], 0
+; CHECK-NEXT:    [[C2:%.*]] = icmp ult i32 [[X2]], 200
+; CHECK-NEXT:    [[C:%.*]] = icmp ult i32 [[Y:%.*]], 100
+; CHECK-NEXT:    [[GW_FREEZE3:%.*]] = freeze i32 [[X]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[GW_FREEZE3]], 3
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], 100
+; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[C]], [[TMP1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = add i32 [[GW_FREEZE3]], 20
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp ult i32 [[TMP3]], 100
+; CHECK-NEXT:    [[WIDE_CHK5:%.*]] = and i1 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK5]]) [ "deopt"(i64 1) ]
+; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
+; CHECK-NEXT:    br i1 [[C2]], label [[OK:%.*]], label [[OUT:%.*]]
+; CHECK:       ok:
+; CHECK-NEXT:    br label [[OUT]]
+; CHECK:       out:
+; CHECK-NEXT:    ret void
+;
+entry:
+  %x1 = add i32 %x, 10
+  %c1 = icmp ult i32 %x1, 100
+  %x2 = add i32 %x, 0
+  %c2 = icmp ult i32 %x2, 200
+  %x3 = add nuw nsw i32 %x, 3
+  %c3 = icmp ult i32 %x3, 100
+  %x4 = add nuw nsw i32 %x, 20
+  %c4 = icmp ult i32 %x4, 100
+  %x5 = add i32 %x, 15
+  %c5 = icmp ult i32 %x5, 100
+  %c = icmp ult i32 %y, 100
+  call void(i1, ...) @llvm.experimental.guard(i1 %c) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c1) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c5) [ "deopt"(i64 5) ]
+  store i32 0, i32* %p
+  br i1 %c2, label %ok, label %out
+ok:
+  call void(i1, ...) @llvm.experimental.guard(i1 %c4) [ "deopt"(i64 4) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c3) [ "deopt"(i64 3) ]
+  br label %out
+out:
+  ret void
+}
+
+; The case checks that base does not need a freeze due to it is known not a poison.
+define void @combine_range_checks_base_neednot_freeze(i32 %y, i32 noundef %x, i32* %p) {
+; CHECK-LABEL: @combine_range_checks_base_neednot_freeze(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[X2:%.*]] = add i32 [[X:%.*]], 0
+; CHECK-NEXT:    [[C2:%.*]] = icmp ult i32 [[X2]], 200
+; CHECK-NEXT:    [[C:%.*]] = icmp ult i32 [[Y:%.*]], 100
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], 100
+; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[C]], [[TMP1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = add i32 [[X]], 20
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp ult i32 [[TMP3]], 100
+; CHECK-NEXT:    [[WIDE_CHK3:%.*]] = and i1 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK3]]) [ "deopt"(i64 1) ]
+; CHECK-NEXT:    store i32 0, i32* [[P:%.*]], align 4
+; CHECK-NEXT:    br i1 [[C2]], label [[OK:%.*]], label [[OUT:%.*]]
+; CHECK:       ok:
+; CHECK-NEXT:    br label [[OUT]]
+; CHECK:       out:
+; CHECK-NEXT:    ret void
+;
+entry:
+  %x1 = add i32 %x, 10
+  %c1 = icmp ult i32 %x1, 100
+  %x2 = add i32 %x, 0
+  %c2 = icmp ult i32 %x2, 200
+  %x3 = add nuw nsw i32 %x, 3
+  %c3 = icmp ult i32 %x3, 100
+  %x4 = add nuw nsw i32 %x, 20
+  %c4 = icmp ult i32 %x4, 100
+  %x5 = add i32 %x, 15
+  %c5 = icmp ult i32 %x5, 100
+  %c = icmp ult i32 %y, 100
+  call void(i1, ...) @llvm.experimental.guard(i1 %c) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c1) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c5) [ "deopt"(i64 5) ]
+  store i32 0, i32* %p
+  br i1 %c2, label %ok, label %out
+ok:
+  call void(i1, ...) @llvm.experimental.guard(i1 %c4) [ "deopt"(i64 4) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c3) [ "deopt"(i64 3) ]
+  br label %out
+out:
+  ret void
+}
+
+; The case checks that length needs a freeze.
+define void @combine_range_checks_length_need_freeze(i32 %y, i32 noundef %x, i32* %p) {
+; CHECK-LABEL: @combine_range_checks_length_need_freeze(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L:%.*]] = load i32, i32* [[P:%.*]], align 4, !range [[RNG0:![0-9]+]]
+; CHECK-NEXT:    [[X2:%.*]] = add i32 [[X:%.*]], 0
+; CHECK-NEXT:    [[C2:%.*]] = icmp ult i32 [[X2]], 200
+; CHECK-NEXT:    [[C:%.*]] = icmp ult i32 [[Y:%.*]], 100
+; CHECK-NEXT:    [[GW_FREEZE3:%.*]] = freeze i32 [[L]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[GW_FREEZE3]]
+; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[C]], [[TMP1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = add i32 [[X]], 20
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp ult i32 [[TMP3]], [[GW_FREEZE3]]
+; CHECK-NEXT:    [[WIDE_CHK5:%.*]] = and i1 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK5]]) [ "deopt"(i64 1) ]
+; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
+; CHECK-NEXT:    br i1 [[C2]], label [[OK:%.*]], label [[OUT:%.*]]
+; CHECK:       ok:
+; CHECK-NEXT:    br label [[OUT]]
+; CHECK:       out:
+; CHECK-NEXT:    ret void
+;
+entry:
+  %L = load i32, i32* %p, !range !1
+  %x1 = add i32 %x, 10
+  %c1 = icmp ult i32 %x1, %L
+  %x2 = add i32 %x, 0
+  %c2 = icmp ult i32 %x2, 200
+  %x3 = add nuw nsw i32 %x, 3
+  %c3 = icmp ult i32 %x3, %L
+  %x4 = add nuw nsw i32 %x, 20
+  %c4 = icmp ult i32 %x4, %L
+  %x5 = add i32 %x, 15
+  %c5 = icmp ult i32 %x5, %L
+  %c = icmp ult i32 %y, 100
+  call void(i1, ...) @llvm.experimental.guard(i1 %c) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c1) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c5) [ "deopt"(i64 5) ]
+  store i32 0, i32* %p
+  br i1 %c2, label %ok, label %out
+ok:
+  call void(i1, ...) @llvm.experimental.guard(i1 %c4) [ "deopt"(i64 4) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c3) [ "deopt"(i64 3) ]
+  br label %out
+out:
+  ret void
+}
+
+; The case checks that base does not need a freeze due to it is known not a posion.
+define void @combine_range_checks_length_neednot_freeze(i32 %y, i32 noundef %x, i32* %p) {
+; CHECK-LABEL: @combine_range_checks_length_neednot_freeze(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[L:%.*]] = load i32, i32* [[P:%.*]], align 4, !range [[RNG0]], !noundef !1
+; CHECK-NEXT:    [[X2:%.*]] = add i32 [[X:%.*]], 0
+; CHECK-NEXT:    [[C2:%.*]] = icmp ult i32 [[X2]], 200
+; CHECK-NEXT:    [[C:%.*]] = icmp ult i32 [[Y:%.*]], 100
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[L]]
+; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[C]], [[TMP1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = add i32 [[X]], 20
+; CHECK-NEXT:    [[TMP4:%.*]] = icmp ult i32 [[TMP3]], [[L]]
+; CHECK-NEXT:    [[WIDE_CHK3:%.*]] = and i1 [[TMP2]], [[TMP4]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK3]]) [ "deopt"(i64 1) ]
+; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
+; CHECK-NEXT:    br i1 [[C2]], label [[OK:%.*]], label [[OUT:%.*]]
+; CHECK:       ok:
+; CHECK-NEXT:    br label [[OUT]]
+; CHECK:       out:
+; CHECK-NEXT:    ret void
+;
+entry:
+  %L = load i32, i32* %p, !range !1, !noundef !{}
+  %x1 = add i32 %x, 10
+  %c1 = icmp ult i32 %x1, %L
+  %x2 = add i32 %x, 0
+  %c2 = icmp ult i32 %x2, 200
+  %x3 = add nuw nsw i32 %x, 3
+  %c3 = icmp ult i32 %x3, %L
+  %x4 = add nuw nsw i32 %x, 20
+  %c4 = icmp ult i32 %x4, %L
+  %x5 = add i32 %x, 15
+  %c5 = icmp ult i32 %x5, %L
+  %c = icmp ult i32 %y, 100
+  call void(i1, ...) @llvm.experimental.guard(i1 %c) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c1) [ "deopt"(i64 1) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c5) [ "deopt"(i64 5) ]
+  store i32 0, i32* %p
+  br i1 %c2, label %ok, label %out
+ok:
+  call void(i1, ...) @llvm.experimental.guard(i1 %c4) [ "deopt"(i64 4) ]
+  call void(i1, ...) @llvm.experimental.guard(i1 %c3) [ "deopt"(i64 3) ]
+  br label %out
+out:
+  ret void
+}
+
+!1 = !{i32 100, i32 200}

llvm/test/Transforms/GuardWidening/range-check-merging.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -guard-widening < %s | FileCheck %s
 
 declare void @llvm.experimental.guard(i1,...)
 
 define void @f_0(i32 %x, i32* %length_buf) {
 ; CHECK-LABEL: @f_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0:![0-9]+]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], 1
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 2
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ult i32 [[TMP4]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP6:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ult i32 [[TMP6]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP5]], [[TMP7]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = add i32 [[X]], 2
 ; CHECK-NEXT:    [[CHK2:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[CHK2]], [[CHK0]]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = add i32 [[X]], 3
 ; CHECK-NEXT:    [[CHK3:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[CHK3]], [[CHK0]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
 
   %x.inc1 = add i32 %x, 1

 
 define void @f_1(i32 %x, i32* %length_buf) {
 ; CHECK-LABEL: @f_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], 1
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ult i32 [[TMP4]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP6:%.*]] = add i32 [[X]], 6
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ult i32 [[TMP6]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP5]], [[TMP7]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = add i32 [[X_INC1]], 2
 ; CHECK-NEXT:    [[CHK2:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[CHK2]], [[CHK0]]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = add i32 [[X_INC2]], 3
 ; CHECK-NEXT:    [[CHK3:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[CHK3]], [[CHK0]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
 
   %x.inc1 = add i32 %x, 1

 define void @f_2(i32 %a, i32* %length_buf) {
 ; CHECK-LABEL: @f_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[X:%.*]] = and i32 [[A:%.*]], -256
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X]], [[LENGTH]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = or i32 [[X]], 1
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 2
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ult i32 [[TMP4]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP6:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ult i32 [[TMP6]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP5]], [[TMP7]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = or i32 [[X]], 2
 ; CHECK-NEXT:    [[CHK2:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[CHK2]], [[CHK0]]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = or i32 [[X]], 3
 ; CHECK-NEXT:    [[CHK3:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[CHK3]], [[CHK0]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %x = and i32 %a, 4294967040 ;; 4294967040 == 0xffffff00
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
 

 define void @f_3(i32 %a, i32* %length_buf) {
 ; CHECK-LABEL: @f_3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[X:%.*]] = and i32 [[A:%.*]], -256
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X]], [[LENGTH]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], 1
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ult i32 [[TMP4]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP6:%.*]] = add i32 [[X]], 6
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ult i32 [[TMP6]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP5]], [[TMP7]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = or i32 [[X_INC1]], 2
 ; CHECK-NEXT:    [[CHK2:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[CHK2]], [[CHK0]]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = add i32 [[X_INC2]], 3
 ; CHECK-NEXT:    [[CHK3:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[CHK3]], [[CHK0]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %x = and i32 %a, 4294967040 ;; 4294967040 == 0xffffff00
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
 

 
 define void @f_4(i32 %x, i32* %length_buf) {
 ; CHECK-LABEL: @f_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], -1024
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], -1024
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 2
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = add i32 [[X]], -1024
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ult i32 [[TMP4]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP6:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ult i32 [[TMP6]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP5]], [[TMP7]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = add i32 [[X]], 2
 ; CHECK-NEXT:    [[CHK2:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[CHK2]], [[CHK1]]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = add i32 [[X]], 3
 ; CHECK-NEXT:    [[CHK3:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[CHK3]], [[CHK1]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 
 ; Note: we NOT guarding on "and i1 %chk3, %chk0", that would be incorrect.
 entry:
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]

 
 define void @f_5(i32 %x, i32* %length_buf) {
 ; CHECK-LABEL: @f_5(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], 1
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], -199
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 1
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP4:%.*]] = add i32 [[X]], -199
+; CHECK-NEXT:    [[TMP5:%.*]] = icmp ult i32 [[TMP4]], [[LENGTH]]
+; CHECK-NEXT:    [[TMP6:%.*]] = add i32 [[X]], 1
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ult i32 [[TMP6]], [[LENGTH]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP5]], [[TMP7]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = add i32 [[X_INC1]], -200
 ; CHECK-NEXT:    [[CHK2:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[CHK1]], [[CHK2]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[CHK1]], [[CHK2]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = add i32 [[X_INC2]], 3
 ; CHECK-NEXT:    [[CHK3:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH]]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]

 ;
 define void @f_6(i32 %x, i32* %length_buf) {
 ; CHECK-LABEL: @f_6(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], -2147483647
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = add i32 [[X]], 2
 ; CHECK-NEXT:    [[CHK2:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[WIDE_CHK]], [[CHK2]]
+; CHECK-NEXT:    [[GW_FREEZE1:%.*]] = freeze i1 [[CHK2]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[WIDE_CHK]], [[GW_FREEZE1]]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = add i32 [[X]], 3
 ; CHECK-NEXT:    [[CHK3:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[WIDE_CHK1]], [[CHK3]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
+; CHECK-NEXT:    [[GW_FREEZE3:%.*]] = freeze i1 [[CHK3]]
+; CHECK-NEXT:    [[WIDE_CHK4:%.*]] = and i1 [[WIDE_CHK2]], [[GW_FREEZE3]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK4]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
 
   %x.inc1 = add i32 %x, -2147483647 ;; -2147483647 == (i32 INT_MIN)+1 == -(i32 INT_MAX)

 ; CHECK-NEXT:    [[LENGTH_B:%.*]] = load volatile i32, i32* [[LENGTH_BUF]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0_A:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH_A]]
 ; CHECK-NEXT:    [[CHK0_B:%.*]] = icmp ult i32 [[X]], [[LENGTH_B]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = and i1 [[CHK0_A]], [[CHK0_B]]
 ; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], 1
 ; CHECK-NEXT:    [[CHK1_A:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH_A]]
 ; CHECK-NEXT:    [[CHK1_B:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH_B]]
 ; CHECK-NEXT:    [[CHK1:%.*]] = and i1 [[CHK1_A]], [[CHK1_B]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
+; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp ult i32 [[TMP0]], [[LENGTH_A]]
+; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[X]], 2
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp ult i32 [[TMP2]], [[LENGTH_A]]
+; CHECK-NEXT:    [[TMP4:%.*]] = and i1 [[TMP1]], [[TMP3]]
+; CHECK-NEXT:    [[TMP5:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP6:%.*]] = icmp ult i32 [[TMP5]], [[LENGTH_B]]
+; CHECK-NEXT:    [[TMP7:%.*]] = and i1 [[TMP4]], [[TMP6]]
+; CHECK-NEXT:    [[TMP8:%.*]] = add i32 [[X]], 2
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp ult i32 [[TMP8]], [[LENGTH_B]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[TMP7]], [[TMP9]]
+; CHECK-NEXT:    [[TMP10:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP11:%.*]] = icmp ult i32 [[TMP10]], [[LENGTH_A]]
+; CHECK-NEXT:    [[TMP12:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP13:%.*]] = icmp ult i32 [[TMP12]], [[LENGTH_A]]
+; CHECK-NEXT:    [[TMP14:%.*]] = and i1 [[TMP11]], [[TMP13]]
+; CHECK-NEXT:    [[TMP15:%.*]] = add i32 [[X]], 0
+; CHECK-NEXT:    [[TMP16:%.*]] = icmp ult i32 [[TMP15]], [[LENGTH_B]]
+; CHECK-NEXT:    [[TMP17:%.*]] = and i1 [[TMP14]], [[TMP16]]
+; CHECK-NEXT:    [[TMP18:%.*]] = add i32 [[X]], 3
+; CHECK-NEXT:    [[TMP19:%.*]] = icmp ult i32 [[TMP18]], [[LENGTH_B]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[TMP17]], [[TMP19]]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[X_INC2:%.*]] = add i32 [[X]], 2
 ; CHECK-NEXT:    [[CHK2_A:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH_A]]
-; CHECK-NEXT:    [[TMP0:%.*]] = and i1 [[CHK2_A]], [[CHK0_A]]
-; CHECK-NEXT:    [[TMP1:%.*]] = and i1 [[CHK0_B]], [[TMP0]]
 ; CHECK-NEXT:    [[CHK2_B:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH_B]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[CHK2_B]], [[TMP1]]
+; CHECK-NEXT:    [[CHK2:%.*]] = and i1 [[CHK2_A]], [[CHK2_B]]
 ; CHECK-NEXT:    [[X_INC3:%.*]] = add i32 [[X]], 3
-; CHECK-NEXT:    [[CHK3_B:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH_B]]
-; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[CHK3_B]], [[CHK0_B]]
-; CHECK-NEXT:    [[TMP3:%.*]] = and i1 [[CHK0_A]], [[TMP2]]
 ; CHECK-NEXT:    [[CHK3_A:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH_A]]
-; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = and i1 [[CHK3_A]], [[TMP3]]
-; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
-; CHECK-NEXT:    [[CHK2:%.*]] = and i1 [[CHK2_A]], [[CHK2_B]]
+; CHECK-NEXT:    [[CHK3_B:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH_B]]
 ; CHECK-NEXT:    [[CHK3:%.*]] = and i1 [[CHK3_A]], [[CHK3_B]]
 ; CHECK-NEXT:    ret void
 ;
 
 
 entry:
   %length_a = load volatile i32, i32* %length_buf, !range !0
   %length_b = load volatile i32, i32* %length_buf, !range !0

 }
 
 define void @f_8(i32 %x, i32* %length_buf) {
 ; Check that we clean nuw nsw flags
 ; CHECK-LABEL: @f_8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
 ; CHECK-NEXT:    [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
-; CHECK-NEXT:    [[X_INC1:%.*]] = add i32 [[X]], 1
+; CHECK-NEXT:    [[X_INC1:%.*]] = add nuw nsw i32 [[X]], 1
 ; CHECK-NEXT:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[GW_FREEZE:%.*]] = freeze i1 [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[GW_FREEZE]]
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %length = load i32, i32* %length_buf, !range !0
   %chk0 = icmp ult i32 %x, %length
   call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]