[GuardWidening] Use logical and in widenCondCommon as it stated in doc

[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 protect us we could use logical and instead of arithmetic and as it states in
widenCondCommon.

This is alternative solution to https://reviews.llvm.org/D128155.
What worries me is that usage of select may break parseRangeChecks logic
where it expects arithmetic and to split already widened condition...

[nikic]

I don't follow the implementation details here, but based on test changes this looks like the right approach.

What worries me is that usage of select may break parseRangeChecks logic
where it expects arithmetic and to split already widened condition...

Possibly you want to replace the matcher there with m_LogicalAnd. This is safe if the range checks in question are of the form X pred C1 && X pred C2, i.e. both work on the same variable, and the other side is a constant. If not, then more care might be needed.

[skatkov]

In D128322#3601261, @nikic wrote:

I don't follow the implementation details here, but based on test changes this looks like the right approach.

What worries me is that usage of select may break parseRangeChecks logic
where it expects arithmetic and to split already widened condition...

Possibly you want to replace the matcher there with m_LogicalAnd. This is safe if the range checks in question are of the form X pred C1 && X pred C2, i.e. both work on the same variable, and the other side is a constant. If not, then more care might be needed.

Let's wait a bit what other say. But it may work.

[reames]

Hm, this adds quite a bit of complexity.

A couple high level thoughts here:

• A good chunk of that complexity comes from the fact that if the original condition involves an and this code expands out to the component checks and then rewrites all at once. Arguable, we should be able able to emit as LogicalAnd(Cond1, Cond2), and then optimize later, but that's not the way this code is currently structured. It might be worth thinking about whether we can reorder the optimization step. (Random thought, not a "please go do this first".)
• The matching logic in this code should probably be extended to handle LogicalAnd.
• Poison can only be introduced in the rewritten condition if a new value reaches the branch. The range check comparison itself can not produce poison. Given that, you may be able to simplify this as "identify values from Cond1 which already produce poison", and then "use logical and or freeze only on values in new range checks not in said set".

[skatkov]

Step forward trying to take into account Philip's comments.

1. Add LagicAnd parsing in range check parser.
2. Utilize the isGuaranteedNotToBeUndefOrPoison function.

Next steps:

1. Re-factor to simplify code.
2. Add a lot of comments
3. Carefully verify all tests to find bugs.
4. Add freeze logic under an option.

[skatkov]

After long offline conversation with Max, we came to conclusion that combineCheck case does not require logical and.
It based on the facts that all conditions in this case are nuw/nsw if first condition is true and the first condition nuw/nsw flags cannot be based on other conditions (due to its constant is minimal one) and can be safely hoisted before the guard as its poison flags (if they exist) are based on something else then on other conditions.

It would be good if someone could verify our conclusion. It looks like the area is very fragile.

[nikic]

llvm/lib/Transforms/Scalar/GuardWidening.cpp

641

m_LogicalAnd also matches m_And, so you can drop the code above.

[skatkov]

llvm/lib/Transforms/Scalar/GuardWidening.cpp

641

Thanks, will update on Monday.

[skatkov]

Dear reviewers, after deeper investigation the issue I guess I come up with the tests https://reviews.llvm.org/D128779 showing the logical and does not resolve the issue and correctly used freeze the only choice.
I would very appreciate if you could review the tests and confirm that my understanding is valid.

[nikic]

In D128322#3617593, @skatkov wrote:

Dear reviewers, after deeper investigation the issue I guess I come up with the tests https://reviews.llvm.org/D128779 showing the logical and does not resolve the issue and correctly used freeze the only choice.
I would very appreciate if you could review the tests and confirm that my understanding is valid.

Yes, I agree with your analysis. The @simple_case test is clearest one I think, because it hoists a condition across other control flow.

Basically, if you have two adjacent llvm.experimental.guard (or separated by must-exec instructions), then they can be combined with logical and. But if they're separated by any (normal or abnormal) control flow, then the second condition must be frozen.

So yeah, we should go back to your original solution using freeze. Sorry for the red herring about logical and.

[skatkov]

In D128322#3617923, @nikic wrote:

In D128322#3617593, @skatkov wrote:

Dear reviewers, after deeper investigation the issue I guess I come up with the tests https://reviews.llvm.org/D128779 showing the logical and does not resolve the issue and correctly used freeze the only choice.
I would very appreciate if you could review the tests and confirm that my understanding is valid.

Yes, I agree with your analysis. The @simple_case test is clearest one I think, because it hoists a condition across other control flow.

Basically, if you have two adjacent llvm.experimental.guard (or separated by must-exec instructions), then they can be combined with logical and. But if they're separated by any (normal or abnormal) control flow, then the second condition must be frozen.

So yeah, we should go back to your original solution using freeze. Sorry for the red herring about logical and.

No need for sorry. It helped to go deeper into optimization. Simple freeze for combine checks does not work as well. Need to figure out how to deal with that.

[skatkov]

Abandon due to it is wrong way to fix this.

llvm/lib/Transforms/Scalar/GuardWidening.cpp

 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/MemorySSAUpdater.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/KnownBits.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/GuardUtils.h"
class GuardWideningImpl {
   /// 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;
     ICmpInst *CheckInst;
+    bool ToWiden;
 
   public:
     explicit RangeCheck(const Value *Base, const ConstantInt *Offset,
-                        const Value *Length, ICmpInst *CheckInst)
-        : Base(Base), Offset(Offset), Length(Length), CheckInst(CheckInst) {}
+                        const Value *Length, ICmpInst *CheckInst, bool ToWiden)
+        : Base(Base), Offset(Offset), Length(Length), CheckInst(CheckInst),
+          ToWiden(ToWiden) {}
 
     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; }
     const APInt &getOffsetValue() const { return getOffset()->getValue(); }
     const Value *getLength() const { return Length; };
     ICmpInst *getCheckInst() const { return CheckInst; }
+    bool getToWiden() const { return ToWiden; }
 
     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,
+                        bool ToWiden) {
     SmallPtrSet<const Value *, 8> Visited;
-    return parseRangeChecks(CheckCond, Checks, Visited);
+    return parseRangeChecks(CheckCond, Checks, Visited, ToWiden);
   }
 
   bool parseRangeChecks(Value *CheckCond, SmallVectorImpl<RangeCheck> &Checks,
-                        SmallPtrSetImpl<const Value *> &Visited);
+                        SmallPtrSetImpl<const Value *> &Visited, bool ToWiden);
 
   /// 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;
 
if (match(Cond0, m_ICmp(Pred0, m_Value(LHS), m_ConstantInt(RHS0))) &&
         }
       }
     }
   }
 
   {
     SmallVector<GuardWideningImpl::RangeCheck, 4> Checks, CombinedChecks;
     // TODO: Support InvertCondition case?
-    if (!InvertCondition &&
-        parseRangeChecks(Cond0, Checks) && parseRangeChecks(Cond1, Checks) &&
+    if (!InvertCondition && parseRangeChecks(Cond0, Checks, true) &&
+        parseRangeChecks(Cond1, Checks, false) &&
         combineRangeChecks(Checks, CombinedChecks)) {
       if (InsertPt) {
         Result = nullptr;
+        DenseMap<Value*, bool> NotAPoisonCache;
+        auto GetNotAPoisonCached = [&](Value *V) {
+          auto It = NotAPoisonCache.find(V);
+          if (It != NotAPoisonCache.end())
+            return It->second;
+          bool R = isGuaranteedNotToBeUndefOrPoison(V, nullptr, InsertPt, &DT);
+          NotAPoisonCache[V] = R;
+          return R;
+        };
+        // Handle first ToWiden range checks.
+        llvm::sort(CombinedChecks,
+                   [&](const GuardWideningImpl::RangeCheck &LHS,
+                       const GuardWideningImpl::RangeCheck &RHS) {
+          if (LHS.getToWiden())
+            return true;
+          if (RHS.getToWiden())
+            return false;
+          if(GetNotAPoisonCached(LHS.getCheckInst()))
+            return true;
+          if(GetNotAPoisonCached(RHS.getCheckInst()))
+            return false;
+          return true;
+        });
+        IRBuilder<> B(InsertPt);
         for (auto &RC : CombinedChecks) {
+          if (RC.getToWiden())
+            assert(DT.dominates(RC.getCheckInst(), InsertPt) &&
+                   "Range check must be available");
+          else
             makeAvailableAt(RC.getCheckInst(), InsertPt);
           if (Result)
-            Result = BinaryOperator::CreateAnd(RC.getCheckInst(), Result, "",
-                                               InsertPt);
+            if (RC.getToWiden() || GetNotAPoisonCached(RC.getCheckInst()))
+              Result = B.CreateAnd(Result, RC.getCheckInst());
+            else
+              Result = B.CreateLogicalAnd(Result, RC.getCheckInst());
           else
             Result = RC.getCheckInst();
         }
         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);
+    assert(DT.dominates(Cond0, InsertPt) && "Cond0 must be available");
     makeAvailableAt(Cond1, InsertPt);
+    IRBuilder<> B(InsertPt);
     if (InvertCondition)
-      Cond1 = BinaryOperator::CreateNot(Cond1, "inverted", InsertPt);
-    Result = BinaryOperator::CreateAnd(Cond0, Cond1, "wide.chk", InsertPt);
+      Cond1 = B.CreateNot(Cond1, "inverted");
+    if (isGuaranteedNotToBeUndefOrPoison(Cond1, nullptr, InsertPt, &DT))
+      Result = B.CreateAnd(Cond0, Cond1, "wide.chk");
+    else
+      Result = B.CreateLogicalAnd(Cond0, Cond1, "wide.chk");
   }
 
   // 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, bool ToWiden) {
   if (!Visited.insert(CheckCond).second)
     return 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, ToWiden) &&
+             parseRangeChecks(AndRHS, Checks, ToWiden);
+  }
+
+  {
+    Value *AndLHS, *AndRHS;
+    if (match(CheckCond, m_LogicalAnd(m_Value(AndLHS), m_Value(AndRHS)))) {
+      return parseRangeChecks(AndLHS, Checks, ToWiden) &&
+             parseRangeChecks(AndRHS, Checks, false);
+    }
   }
 
   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);
   if (IC->getPredicate() == ICmpInst::ICMP_UGT)
     std::swap(CmpLHS, CmpRHS);
 
   auto &DL = IC->getModule()->getDataLayout();
 
   GuardWideningImpl::RangeCheck Check(
       CmpLHS, cast<ConstantInt>(ConstantInt::getNullValue(CmpRHS->getType())),
-      CmpRHS, IC);
+      CmpRHS, IC, ToWiden);
 
   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;

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
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[WIDE_CHK]], [[COND_2:%.*]]
+; CHECK-NEXT:    store i32 0, i32* @G, align 4
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = select i1 [[WIDE_CHK]], i1 [[COND_2:%.*]], i1 false
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK1]]) [ "deopt"(i32 0) ]
-; CHECK-NEXT:    store i32 1, i32* @G
-; CHECK-NEXT:    store i32 2, i32* @G
-; CHECK-NEXT:    store i32 3, i32* @G
+; 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
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
-; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = and i1 [[WIDE_CHK]], [[COND_2:%.*]]
+; CHECK-NEXT:    store i32 0, i32* @G, align 4
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = select i1 [[WIDE_CHK]], i1 [[COND_2:%.*]], i1 false
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK1]]) [ "deopt"(i32 0) ]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    store i32 1, i32* @G
-; CHECK-NEXT:    store i32 2, i32* @G
-; CHECK-NEXT:    store i32 3, i32* @G
+; 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:
   store i32 0, i32* @G
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"(i32 0) ]
   br label %loop
 
 loop:
   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 @dont_widen_over_common_exit(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
 ; CHECK-LABEL: @dont_widen_over_common_exit(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    store i32 0, i32* @G
+; CHECK-NEXT:    store i32 0, i32* @G, align 4
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0:%.*]]) [ "deopt"(i32 0) ]
-; CHECK-NEXT:    store i32 1, i32* @G
+; 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
+; CHECK-NEXT:    store i32 2, i32* @G, align 4
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_2:%.*]]) [ "deopt"(i32 2) ]
-; CHECK-NEXT:    store i32 3, i32* @G
+; CHECK-NEXT:    store i32 3, i32* @G, align 4
 ; CHECK-NEXT:    br label [[LOOP]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %loop
 
 loop:

 
 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
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_2:%.*]]
+; CHECK-NEXT:    store i32 0, i32* @G, align 4
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_2:%.*]], i1 false
 ; 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
+; 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
-; CHECK-NEXT:    store i32 3, i32* @G
+; CHECK-NEXT:    store i32 2, i32* @G, align 4
+; CHECK-NEXT:    store i32 3, i32* @G, align 4
 ; CHECK-NEXT:    br label [[LOOP]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   store i32 0, i32* @G
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"(i32 0) ]
   br label %loop

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:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+;
 entry:
-; CHECK:  %wide.chk = and i1 %cond_0, %cond_1
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  ret void
 
   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:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
+; 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
+;
 entry:
-; CHECK:  %wide.chk = and i1 %cond_0, %cond_1
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  br i1 undef, label %left, label %right
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %left, label %right
 
 left:
   br label %merge
 
 right:
   br label %merge
 
 merge:
-; CHECK: merge:
-; CHECK-NOT: call void (i1, ...) @llvm.experimental.guard(
-; CHECK: ret void
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   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:%.*]] = select i1 [[COND_0]], i1 [[COND_1]], i1 false
+; 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
+;
 entry:
-; CHECK:  %cond_0 = icmp ult i32 %a, 10
-; CHECK:  %cond_1 = icmp ult i32 %b, 10
-; CHECK:  %wide.chk = and i1 %cond_0, %cond_1
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  br i1 undef, label %left, label %right
 
   %cond_0 = icmp ult i32 %a, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %left, label %right
 
 left:
   br label %merge
 
 right:
   br label %merge
 
 merge:
   %cond_1 = icmp ult i32 %b, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 }
 
 ; Negative test: don't hoist stuff out of control flow
 ; indiscriminately, since that can make us do more work than needed.
 define void @f_3(i32 %a, i32 %b) {
 ; CHECK-LABEL: @f_3(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0]]) [ "deopt"() ]
+; CHECK-NEXT:    br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
+; CHECK:       left:
+; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_1]]) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+; CHECK:       right:
+; CHECK-NEXT:    ret void
+;
 entry:
-; CHECK:  %cond_0 = icmp ult i32 %a, 10
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
-; CHECK:  br i1 undef, label %left, label %right
 
   %cond_0 = icmp ult i32 %a, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %left, label %right
 
 left:
-; CHECK: left:
-; CHECK:   %cond_1 = icmp ult i32 %b, 10
-; CHECK:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
-; CHECK:   ret void
 
   %cond_1 = icmp ult i32 %b, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 
 right:
   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:%.*]] = select i1 [[COND_0]], i1 [[COND_1]], i1 false
+; 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:
-; CHECK:  %cond_0 = icmp ult i32 %a, 10
-; CHECK:  %cond_1 = icmp ult i32 %b, 10
-; CHECK:  %wide.chk = and i1 %cond_0, %cond_1
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  br i1 undef, label %loop, label %leave
 
   %cond_0 = icmp ult i32 %a, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %loop, label %leave
 
 loop:
   %cond_1 = icmp ult i32 %b, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   br i1 undef, label %loop, label %leave
 
 leave:
   ret void
 }
 
 ; Hoisting out of control flow is also fine if we can widen the
 ; dominating check without doing any extra work.
 define void @f_5(i32 %a) {
 ; CHECK-LABEL: @f_5(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[COND_0:%.*]] = icmp ugt i32 [[A:%.*]], 7
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = icmp uge i32 [[A]], 11
+; 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:    [[COND_1:%.*]] = icmp ugt i32 [[A]], 10
+; CHECK-NEXT:    ret void
+; CHECK:       right:
+; CHECK-NEXT:    ret void
+;
 entry:
-; CHECK:  %wide.chk = icmp uge i32 %a, 11
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  br i1 undef, label %left, label %right
 
   %cond_0 = icmp ugt i32 %a, 7
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %left, label %right
 
 left:
   %cond_1 = icmp ugt i32 %a, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 
 right:
   ret void
 }
 
 ; Negative test: the load from %a can be safely speculated to before
 ; the first guard, but there is no guarantee that it will produce the
 ; same value.
 define void @f_6(i1* dereferenceable(32) %a, i1* %b, i1 %unknown) {
 ; CHECK-LABEL: @f_6(
-; CHECK: call void (i1, ...) @llvm.experimental.guard(
-; CHECK: call void (i1, ...) @llvm.experimental.guard(
-; CHECK: ret void
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[COND_0:%.*]] = load i1, i1* [[A:%.*]], align 1
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0]]) [ "deopt"() ]
+; CHECK-NEXT:    store i1 [[UNKNOWN:%.*]], i1* [[B:%.*]], align 1
+; CHECK-NEXT:    [[COND_1:%.*]] = load i1, i1* [[A]], align 1
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_1]]) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+;
 entry:
   %cond_0 = load i1, i1* %a
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   store i1 %unknown, i1* %b
   %cond_1 = load i1, i1* %a
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 }
 
 ; 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:%.*]] = select i1 [[COND_1]], i1 [[COND_3]], i1 false
+; 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
+;
 entry:
-; CHECK:  %cond_1 = load volatile i1, i1* %cond_buf
-; CHECK:  %cond_3 = icmp ult i32 %a, 7
-; CHECK:  %wide.chk = and i1 %cond_1, %cond_3
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  %cond_2 = load volatile i1, i1* %cond_buf
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"() ]
-; CHECK:  br i1 undef, label %left, label %right
 
   %cond_1 = load volatile i1, i1* %cond_buf
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   %cond_2 = load volatile i1, i1* %cond_buf
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"() ]
   br i1 undef, label %left, label %right
 
 left:
   %cond_3 = icmp ult i32 %a, 7
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_3) [ "deopt"() ]
   br label %left
 
 right:
   ret void
 }
 
 ; In this case the earliest dominating guard is in a loop, and we
 ; don't want to put extra work in there.  This heuristic can use some
 ; tuning.
 define void @f_8(i32 %a, i1 %cond_1, i1 %cond_2) {
 ; 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:%.*]] = select i1 [[COND_2:%.*]], i1 [[COND_3]], i1 false
+; 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:
   br label %loop
 
 loop:
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   br i1 undef, label %loop, label %leave
 
 leave:
-; CHECK: leave:
-; CHECK:  %cond_3 = icmp ult i32 %a, 7
-; CHECK:  %wide.chk = and i1 %cond_2, %cond_3
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  br i1 undef, label %loop2, label %leave2
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"() ]
   br i1 undef, label %loop2, label %leave2
 
 loop2:
   %cond_3 = icmp ult i32 %a, 7
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_3) [ "deopt"() ]
   br label %loop2
 
 leave2:
   ret void
 }
 
 ; In cases like these where there isn't any "obviously profitable"
 ; widening sites, we refuse to do anything.
 define void @f_9(i32 %a, i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_9(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[FIRST_LOOP:%.*]]
+; CHECK:       first_loop:
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0:%.*]]) [ "deopt"() ]
+; CHECK-NEXT:    br i1 undef, label [[FIRST_LOOP]], label [[SECOND_LOOP:%.*]]
+; CHECK:       second_loop:
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_1:%.*]]) [ "deopt"() ]
+; CHECK-NEXT:    br label [[SECOND_LOOP]]
+;
 entry:
   br label %first_loop
 
 first_loop:
-; CHECK: first_loop:
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
-; CHECK:  br i1 undef, label %first_loop, label %second_loop
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %first_loop, label %second_loop
 
 second_loop:
-; CHECK: second_loop:
-; CHECK:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
-; CHECK:   br label %second_loop
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   br label %second_loop
 }
 
 ; Same situation as in @f_9: no "obviously profitable" widening sites,
 ; so we refuse to do anything.
 define void @f_10(i32 %a, i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_10(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br label [[LOOP:%.*]]
+; CHECK:       loop:
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0:%.*]]) [ "deopt"() ]
+; CHECK-NEXT:    br i1 undef, label [[LOOP]], label [[NO_LOOP:%.*]]
+; CHECK:       no_loop:
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_1:%.*]]) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+;
 entry:
   br label %loop
 
 loop:
-; CHECK: loop:
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
-; CHECK:  br i1 undef, label %loop, label %no_loop
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %loop, label %no_loop
 
 no_loop:
-; CHECK: no_loop:
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
-; CHECK:  ret void
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 }
 
 ; 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:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
+; 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:
-; CHECK: inner:
-; CHECK:  %wide.chk = and i1 %cond_0, %cond_1
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  br i1 undef, label %inner, label %outer
 
   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-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:    [[A10:%.*]] = mul i32 [[A9]], [[A9]]
+; CHECK-NEXT:    [[A11:%.*]] = mul i32 [[A10]], [[A10]]
+; CHECK-NEXT:    [[A12:%.*]] = mul i32 [[A11]], [[A11]]
+; CHECK-NEXT:    [[A13:%.*]] = mul i32 [[A12]], [[A12]]
+; CHECK-NEXT:    [[A14:%.*]] = mul i32 [[A13]], [[A13]]
+; CHECK-NEXT:    [[A15:%.*]] = mul i32 [[A14]], [[A14]]
+; CHECK-NEXT:    [[A16:%.*]] = mul i32 [[A15]], [[A15]]
+; CHECK-NEXT:    [[A17:%.*]] = mul i32 [[A16]], [[A16]]
+; CHECK-NEXT:    [[A18:%.*]] = mul i32 [[A17]], [[A17]]
+; CHECK-NEXT:    [[A19:%.*]] = mul i32 [[A18]], [[A18]]
+; CHECK-NEXT:    [[A20:%.*]] = mul i32 [[A19]], [[A19]]
+; CHECK-NEXT:    [[A21:%.*]] = mul i32 [[A20]], [[A20]]
+; CHECK-NEXT:    [[A22:%.*]] = mul i32 [[A21]], [[A21]]
+; CHECK-NEXT:    [[A23:%.*]] = mul i32 [[A22]], [[A22]]
+; 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:%.*]] = select i1 true, i1 [[COND]], i1 false
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+;
 
 ; Eliding the earlier 29 multiplications for brevity
-; CHECK:  %a30 = mul i32 %a29, %a29
-; CHECK-NEXT:  %cond = trunc i32 %a30 to i1
-; CHECK-NEXT:  %wide.chk = and i1 true, %cond
-; CHECK-NEXT:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK-NEXT:  ret void
 
 entry:
   call void(i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
   %a1 = mul i32 %a0, %a0
   %a2 = mul i32 %a1, %a1
   %a3 = mul i32 %a2, %a2
   %a4 = mul i32 %a3, %a3
   %a5 = mul i32 %a4, %a4
entry:
   %a30 = mul i32 %a29, %a29
   %cond = trunc i32 %a30 to i1
   call void(i1, ...) @llvm.experimental.guard(i1 %cond) [ "deopt"() ]
   ret void
 }
 
 define void @f_13(i32 %a) {
 ; CHECK-LABEL: @f_13(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 14
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = icmp ult i32 [[A]], 10
+; 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:    [[COND_1:%.*]] = icmp slt i32 [[A]], 10
+; CHECK-NEXT:    ret void
+; CHECK:       right:
+; CHECK-NEXT:    ret void
+;
 entry:
-; CHECK:  %wide.chk = icmp ult i32 %a, 10
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK:  br i1 undef, label %left, label %right
 
   %cond_0 = icmp ult i32 %a, 14
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %left, label %right
 
 left:
   %cond_1 = icmp slt i32 %a, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 
 right:
   ret void
 }
 
 define void @f_14(i32 %a) {
 ; CHECK-LABEL: @f_14(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 14
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0]]) [ "deopt"() ]
+; CHECK-NEXT:    br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
+; CHECK:       left:
+; CHECK-NEXT:    [[COND_1:%.*]] = icmp sgt i32 [[A]], 10
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_1]]) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+; CHECK:       right:
+; CHECK-NEXT:    ret void
+;
 entry:
-; CHECK:  %cond_0 = icmp ult i32 %a, 14
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
-; CHECK:  br i1 undef, label %left, label %right
 
   %cond_0 = icmp ult i32 %a, 14
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br i1 undef, label %left, label %right
 
 left:
-; CHECK: left:
-; CHECK:  %cond_1 = icmp sgt i32 %a, 10
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
 
   %cond_1 = icmp sgt i32 %a, 10
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   ret void
 
 right:
   ret void
 }
 
 ; Make sure we do not widen guard by trivial true conditions into something.
 define void @f_15(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_15(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0:%.*]]) [ "deopt"() ]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+;
 entry:
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
-; CHECK:  ret void
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   call void(i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
   ret void
 }
 
 ; Make sure we do not widen guard by trivial false conditions into something.
 define void @f_16(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_16(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0:%.*]]) [ "deopt"() ]
+; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 false) [ "deopt"() ]
+; CHECK-NEXT:    ret void
+;
 entry:
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 false) [ "deopt"() ]
-; CHECK:  ret void
 
   call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   call void(i1, ...) @llvm.experimental.guard(i1 false) [ "deopt"() ]
   ret void
 }

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:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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]]
-; CHECK-NEXT:    br i1 true, label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()
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:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:
 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       right:
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
 ; 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 !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()

 ; 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:    [[WIDE_CHK:%.*]] = select i1 [[COND_0]], i1 [[COND_1]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:
 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       right:
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
 ; 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 !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ;
 entry:
   %cond_0 = icmp ult i32 %a, 10

 ; Negative test: don't hoist stuff out of control flow
 ; indiscriminately, since that can make us do more work than needed.
 define void @f_3(i32 %a, i32 %b) {
 ; CHECK-LABEL: @f_3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
 ; 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 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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:    ret void
 ; CHECK:       right:
 ; CHECK-NEXT:    ret void
 ;

 ; 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:    [[WIDE_CHK:%.*]] = select i1 [[COND_0]], i1 [[COND_1]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:
 ; 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 !0
+; CHECK-NEXT:    br i1 true, 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 [[LOOP]], label [[LEAVE]]
 ; CHECK:       leave:
 ; CHECK-NEXT:    ret void
 ;

 ; dominating check without doing any extra work.
 define void @f_5(i32 %a) {
 ; CHECK-LABEL: @f_5(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ugt i32 [[A:%.*]], 7
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[WIDE_CHK:%.*]] = icmp uge i32 [[A]], 11
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp ugt i32 [[A]], 10
 ; 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 !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ; CHECK:       right:
 ; CHECK-NEXT:    ret void
 ;

 }
 
 ; Negative test: the load from %a can be safely speculated to before
 ; the first guard, but there is no guarantee that it will produce the
 ; same value.
 define void @f_6(i1* dereferenceable(32) %a, i1* %b, i1 %unknown) {
 ; CHECK-LABEL: @f_6(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[COND_0:%.*]] = load i1, i1* [[A:%.*]]
+; CHECK-NEXT:    [[COND_0:%.*]] = load i1, i1* [[A:%.*]], align 1
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:    store i1 [[UNKNOWN:%.*]], i1* [[B:%.*]]
-; CHECK-NEXT:    [[COND_1:%.*]] = load i1, i1* [[A]]
+; CHECK-NEXT:    store i1 [[UNKNOWN:%.*]], i1* [[B:%.*]], align 1
+; CHECK-NEXT:    [[COND_1:%.*]] = load i1, i1* [[A]], align 1
 ; 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 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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:    ret void
 ;
 entry:
   %cond_0 = load i1, i1* %a
guarded1:                                         ; preds = %guarded
   ret void
 }
 
 ; 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:%.*]]
+; 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:    [[WIDE_CHK:%.*]] = select i1 [[COND_1]], i1 [[COND_3]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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]]
+; CHECK-NEXT:    [[COND_2:%.*]] = load volatile i1, i1* [[COND_BUF]], align 1
 ; CHECK-NEXT:    [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND_2]], [[WIDENABLE_COND3]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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 [[LEFT:%.*]], label [[RIGHT:%.*]]
 ; CHECK:       left:
 ; CHECK-NEXT:    [[WIDENABLE_COND7:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND8:%.*]] = and i1 [[COND_3]], [[WIDENABLE_COND7]]
-; CHECK-NEXT:    br i1 true, label [[GUARDED5:%.*]], label [[DEOPT6:%.*]], !prof !0
+; CHECK-NEXT:    br i1 true, label [[GUARDED5:%.*]], label [[DEOPT6:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt6:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded5:
 ; CHECK-NEXT:    br label [[LEFT]]
 ; CHECK:       right:
 ; CHECK-NEXT:    ret void
 ;

 ; tuning.
 define void @f_8(i32 %a, i1 %cond_1, i1 %cond_2) {
 ; CHECK-LABEL: @f_8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_1:%.*]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:       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:    [[WIDE_CHK:%.*]] = select i1 [[COND_2:%.*]], i1 [[COND_3]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND3]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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:
 ; CHECK-NEXT:    [[WIDENABLE_COND7:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND8:%.*]] = and i1 [[COND_3]], [[WIDENABLE_COND7]]
-; CHECK-NEXT:    br i1 true, label [[GUARDED5:%.*]], label [[DEOPT6:%.*]], !prof !0
+; CHECK-NEXT:    br i1 true, label [[GUARDED5:%.*]], label [[DEOPT6:%.*]], !prof [[PROF0]]
 ; CHECK:       deopt6:
 ; CHECK-NEXT:    call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
 ; CHECK-NEXT:    ret void
 ; CHECK:       guarded5:
 ; CHECK-NEXT:    br label [[LOOP2]]
 ; CHECK:       leave2:
 ; CHECK-NEXT:    ret void
 ;

 ; widening sites, we refuse to do anything.
 define void @f_9(i32 %a, i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_9(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FIRST_LOOP:%.*]]
 ; CHECK:       first_loop:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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 [[FIRST_LOOP]], label [[SECOND_LOOP:%.*]]
 ; CHECK:       second_loop:
 ; 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 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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 label [[SECOND_LOOP]]
 ;
 entry:
   br label %first_loop

 ; so we refuse to do anything.
 define void @f_10(i32 %a, i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_10(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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 [[NO_LOOP:%.*]]
 ; CHECK:       no_loop:
 ; 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 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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:    ret void
 ;
 entry:
   br label %loop

 ; 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:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:    [[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 !0
+; CHECK-NEXT:    br i1 true, 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 [[INNER]], label [[OUTER_LATCH:%.*]]
 ; CHECK:       outer_latch:
 ; CHECK-NEXT:    br i1 undef, label [[OUTER_HEADER]], label [[EXIT:%.*]]
 ; CHECK:       exit:

 ; 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:    [[WIDE_CHK:%.*]] = select i1 true, i1 [[COND]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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]]
-; CHECK-NEXT:    br i1 true, label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()

 
 define void @f_13(i32 %a) {
 ; CHECK-LABEL: @f_13(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 14
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[WIDE_CHK:%.*]] = icmp ult i32 [[A]], 10
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp slt i32 [[A]], 10
 ; 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 !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ; CHECK:       right:
 ; CHECK-NEXT:    ret void
 ;

 }
 
 define void @f_14(i32 %a) {
 ; CHECK-LABEL: @f_14(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 14
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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:
 ; CHECK-NEXT:    [[COND_1:%.*]] = icmp sgt i32 [[A]], 10
 ; 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 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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:    ret void
 ; CHECK:       right:
 ; CHECK-NEXT:    ret void
 ;

 }
 
 ; Make sure we do not widen guard by trivial true conditions into something.
 define void @f_15(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_15(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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 true, [[WIDENABLE_COND3]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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:    ret void
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()

 }
 
 ; Make sure we do not widen guard by trivial false conditions into something.
 define void @f_16(i1 %cond_0, i1 %cond_1) {
 ; CHECK-LABEL: @f_16(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0:%.*]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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 false, [[WIDENABLE_COND3]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; 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:    ret void
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()
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:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
 ; CHECK-NEXT:    [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[WIDENABLE_COND]], [[WIDE_CHK]]
-; CHECK-NEXT:    br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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]]
-; CHECK-NEXT:    br i1 true, label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()

 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:    [[WIDE_CHK:%.*]] = select i1 true, i1 [[COND_0:%.*]], i1 false
 ; CHECK-NEXT:    [[TMP0:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[TMP0]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; 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]]
-; CHECK-NEXT:    br i1 true, label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof !0
+; CHECK-NEXT:    br i1 true, 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:    ret void
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes='licm,guard-widening,licm' -verify-memoryssa -debug-pass-manager < %s 2>&1 | FileCheck %s
 
 ; Main point of this test is to check the scheduling -- there should be
 ; no analysis passes needed between LICM and LoopGuardWidening
 
 ; CHECK: LICMPass
 ; CHECK-NEXT: GuardWideningPass
 ; CHECK-NEXT: LICMPass
 
 declare void @llvm.experimental.guard(i1,...)
 
 define void @iter(i32 %a, i32 %b, i1* %c_p) {
-; CHECK-LABEL: @iter
-; CHECK:  %cond_0 = icmp ult i32 %a, 10
-; CHECK:  %cond_1 = icmp ult i32 %b, 10
-; CHECK:  %wide.chk = and i1 %cond_0, %cond_1
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK-LABEL: loop:
+; 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:%.*]] = select i1 [[COND_0]], i1 [[COND_1]], i1 false
+; 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:
+; CHECK-NEXT:    ret void
+;
 
 entry:
   %cond_0 = icmp ult i32 %a, 10
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   br label %loop
 
 loop:                                             ; preds = %loop.preheader, %loop
   %cond_1 = icmp ult i32 %b, 10
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
   %cnd = load i1, i1* %c_p
   br i1 %cnd, label %loop, label %leave.loopexit
 
 leave.loopexit:                                   ; preds = %loop
   br label %leave
 
 leave:                                            ; preds = %leave.loopexit, %entry
   ret void
 }
 
 define void @within_loop(i32 %a, i32 %b, i1* %c_p) {
-; CHECK-LABEL: @within_loop
-; CHECK:  %cond_0 = icmp ult i32 %a, 10
-; CHECK:  %cond_1 = icmp ult i32 %b, 10
-; CHECK:  %wide.chk = and i1 %cond_0, %cond_1
-; CHECK:  call void (i1, ...) @llvm.experimental.guard(i1 %wide.chk) [ "deopt"() ]
-; CHECK-LABEL: loop:
+; 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:%.*]] = select i1 [[COND_0]], i1 [[COND_1]], i1 false
+; 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:
+; CHECK-NEXT:    ret void
+;
 
 entry:
   br label %loop
 
 loop:                                             ; preds = %loop.preheader, %loop
   %cond_0 = icmp ult i32 %a, 10
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
   %cond_1 = icmp ult i32 %b, 10

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:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
 ; 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 !0
+; 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:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
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:    [[GUARD_CHK:%.*]] = and i1 [[WIDE_CHK]], [[WIDENABLE_COND]]
-; CHECK-NEXT:    br i1 [[GUARD_CHK]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof !0
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = select i1 [[COND_0:%.*]], i1 [[COND_1:%.*]], i1 false
+; 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
 ;
 entry:
   %widenable_cond = call i1 @llvm.experimental.widenable.condition()

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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK1:%.*]] = select i1 [[CHK0]], i1 [[CHK2]], i1 false
 ; 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:    [[WIDE_CHK2:%.*]] = select i1 [[CHK0]], i1 [[CHK3]], i1 false
 ; 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"() ]
 

 
 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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK1:%.*]] = select i1 [[CHK0]], i1 [[CHK2]], i1 false
 ; 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:    [[WIDE_CHK2:%.*]] = select i1 [[CHK0]], i1 [[CHK3]], i1 false
 ; 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"() ]
 

 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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK1:%.*]] = select i1 [[CHK0]], i1 [[CHK2]], i1 false
 ; 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:    [[WIDE_CHK2:%.*]] = select i1 [[CHK0]], i1 [[CHK3]], i1 false
 ; 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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK1:%.*]] = select i1 [[CHK0]], i1 [[CHK2]], i1 false
 ; 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:    [[WIDE_CHK2:%.*]] = select i1 [[CHK0]], i1 [[CHK3]], i1 false
 ; 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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK1:%.*]] = select i1 [[CHK2]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK2:%.*]] = select i1 [[CHK3]], i1 [[CHK1]], i1 false
 ; 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

 
 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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK1:%.*]] = select i1 [[CHK1]], i1 [[CHK2]], i1 false
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = select i1 [[CHK1]], i1 [[CHK2]], i1 false
 ; 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

 ;
 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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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:    [[WIDE_CHK1:%.*]] = select i1 [[WIDE_CHK]], i1 [[CHK2]], i1 false
 ; 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:    [[WIDE_CHK2:%.*]] = select i1 [[WIDE_CHK1]], i1 [[CHK3]], i1 false
 ; 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"() ]
 

 ; 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:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
+; CHECK-NEXT:    [[TMP0:%.*]] = and i1 [[CHK0_B]], [[CHK0_A]]
 ; 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:    [[TMP1:%.*]] = select i1 [[TMP0]], i1 [[CHK2_B]], i1 false
+; CHECK-NEXT:    [[CHK2_A:%.*]] = icmp ult i32 [[X_INC2]], [[LENGTH_A]]
+; CHECK-NEXT:    [[WIDE_CHK1:%.*]] = select i1 [[TMP1]], i1 [[CHK2_A]], i1 false
+; CHECK-NEXT:    [[TMP2:%.*]] = and i1 [[CHK0_A]], [[CHK0_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:    [[TMP3:%.*]] = select i1 [[TMP2]], i1 [[CHK3_A]], i1 false
+; CHECK-NEXT:    [[CHK3_B:%.*]] = icmp ult i32 [[X_INC3]], [[LENGTH_B]]
+; CHECK-NEXT:    [[WIDE_CHK2:%.*]] = select i1 [[TMP3]], i1 [[CHK3_B]], i1 false
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"() ]
 ; CHECK-NEXT:    [[CHK2:%.*]] = and i1 [[CHK2_A]], [[CHK2_B]]
 ; CHECK-NEXT:    [[CHK3:%.*]] = and i1 [[CHK3_A]], [[CHK3_B]]
 ; CHECK-NEXT:    ret void
 ;
 
 
 entry:

 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:    [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
-; CHECK-NEXT:    [[WIDE_CHK:%.*]] = and i1 [[CHK0]], [[CHK1]]
+; CHECK-NEXT:    [[WIDE_CHK:%.*]] = select i1 [[CHK0]], i1 [[CHK1]], i1 false
 ; 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"() ]