[SimpleLoopUnswitch] Fix introduction of UB when hoisted condition may be undef or poison

[aqjune]

Summary

Loop unswitch hoists branches on loop-invariant conditions. However, if this
condition is poison/undef and the branch wasn't originally reachable, loop
unswitch introduces UB (since the optimized code will branch on poison/undef and
the original one didn't)).
We fix this problem by freezing the condition to ensure we don't introduce UB.

We will now transform the following:

while (...) {
  if (C) { A }
  else   { B }
}

Into:

C' = freeze(C)
if (C') {
  while (...) { A }
} else {
  while (...) { B }
}

This patch fixes the root cause of the following bug reports (which use the old loop unswitch, but can be reproduced with minor changes in the code and -enable-nontrivial-unswitch):

• https://llvm.org/bugs/show_bug.cgi?id=27506
• https://llvm.org/bugs/show_bug.cgi?id=31652

[aqjune]

• Move IRBuilder::CreateFreezeAtDef from https://reviews.llvm.org/D29011

[filcab]

Is NeedFreeze always true? If so, why have the parameter?
If not, when is it not?

include/llvm/IR/IRBuilder.h

1798

Maybe add

if (isa<FreezeInst>(Arg))
  return Arg;

so we don't need to create a FreezeInst that will be immediately simplified in the next run of instsimplify (and avoids ReplaceAllUsesWith)?
Unless I missed something.

1814

What happens if we try to Freeze a non-Instruction, non-Argument Value subclass (any type of Constant?)?
From the name and location, I'm assuming this function should be fairly generic.

lib/Transforms/Scalar/LoopUnswitch.cpp

229

Why is it a default parameter here?

[aqjune]

include/llvm/IR/IRBuilder.h

1798

@filcab I think it is caller's job to check whether the value is simple enough and creating a new freeze is unnecessary. A function FreezeBranchCondition in this patch (which is in LoopUnswitch.cpp) does similar thing : first of all it checks whether the new freeze instruction is needed (by calling isGuaranteedNotToBeUndefOrPoison), and then calls this function (CreateFreezeAtDef).

[aqjune]

NeedFreeze is set to true in this patch, but it can have different value in upcoming patch (https://reviews.llvm.org/D29016).

[aqjune]

Rebased to svn commit 308173

[reames]

p.s. You know you're changing the old pass which isn't used in the new pass manager right? You may instead wish to focus on SimpleLoopUnswitch which is the new version.

include/llvm/IR/IRBuilder.h

1795

This is really not idiomatic for an IRBuilder function. The standard idioms is to just insert the requested instruction sequence at the specified insertion point. Please refactor to match that idiom and move other logic to caller or utility outside of IRBuilder.

lib/Transforms/Scalar/LoopUnswitch.cpp

229

Please leave this out of the current patch. It belongs in the one using the must execute logic.

I'd be open to combining them if you thought that was needed.

897

I think this can and should be simpler. If we need a freeze, just insert it into the end of the preheader. The complexity of hoisting to def doesn't seem warranted.

[aqjune]

• Target SimpleLoopUnswitch to fix introduction of UB
• Use ICFLoopSafetyInfo::isGuaranteedToExecute to not freeze condition if hoisted branch is guaranteed to be reachable

The second change was necessary to minimize the updates at unit tests.
(which was https://reviews.llvm.org/D29016 , but it needed only small amount of change so I moved it to here)

[reames]

LGTM

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

2179 ↗

(On Diff #242267)

As a further enhancement (separate change), I think you can improve the logic for this case slightly. If you can prove that the original condition would have triggered UB if any of the invariant components had been poison, then you can avoid the freeze on the partially unswitched condition.

[aqjune]

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

2179 ↗

(On Diff #242267)

IIUC, it is addressed by this patch because we could exploit that branching on poison is UB:

// want to partial unswitch cond2
for (..)
  if (cond1 && cond2) { A } else { B } // if cond2 is poison, cond1 && cond2 is also poison, so this is UB
=>
if (cond2) // freeze is not needed here
  for (..) { if (cond1) { A } }
else
  for (..) { B }

[aqjune]

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

2179 ↗

(On Diff #242267)

(to clarify, it is assumed in the example that if(cond1 && cond2) is guaranteed to execute, meaning that there is no intervening branch or function call that may not return between the if statement and loop preheader )

[jdoerfert]

Thx for the patch!

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

186 ↗

(On Diff #246622)

Nit: InsertFreze

[aqjune]

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

186 ↗

(On Diff #246622)

Fixed via https://github.com/llvm/llvm-project/commit/1cb7ec870dc5c6b3900bfc832b910010dfac772b

[aqjune]

Reverted due to performance reason (https://github.com/llvm/llvm-project/commit/2b5a8976514de326bb84f0913d9d451089c11d22 ) ; LICM/CSE support for freeze is needed

[aqjune]

Now we have a pass for removing freezes in a loop (D77524). I can check whether the existing slowdowns can be addressed with it. I'll be a bit busy for a month, so it may proceed a bit slowly.
BTW, having an attribute for function arguments that states the value is already frozen will be really helpful for reducing the amount of introduced freezes (not only for loop unswitch, but also for other transformations that need freeze operations). I remember that it was called nonpoison in the previous llvm-dev discussion.
According to C/C++ standard, if indeterminate value is produced by an evaluation, the behavior is undefined except when the value was a family of char type:
C++14: https://timsong-cpp.github.io/cppwp/n4140/dcl.init#12
C++17: https://timsong-cpp.github.io/cppwp/n4659/dcl.init#12
C++11: https://timsong-cpp.github.io/cppwp/n3337/conv.lval#1 (wording is a bit different)
C11: https://port70.net/~nsz/c/c11/n1570.html#6.3.2.1p2
This means that it is valid to put the attribute unless the type is char or an aggregate with char when translating C/C++ to IR.
What do you think? @jdoerfert @reames This will help support other optimizations, such as supporting hoisting divisions from a loop when its divisor is a non-zero value derived from a function argument.

include/llvm/IR/IRBuilder.h

public:
   }
 
   /// \brief Return an i1 value testing if \p Arg is not null.
   Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
     return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
                         Name);
   }
 
+  /// \brief Insert a freeze instruction at the definition of \p Arg and return
+  /// the new value.
+  Value *CreateFreezeAtDef(Value *Arg, Function *F, const Twine &Name = "",
+                           bool replaceAllUses = true) {
+    FreezeInst *FI = nullptr;
+
+    if (Instruction *I = dyn_cast<Instruction>(Arg)) {
+      FI = new FreezeInst(I, Name);
+      BasicBlock *BB = I->getParent();
+
+      if (isa<PHINode>(I)) {
+        BB->getInstList().insert(BB->getFirstInsertionPt(), FI);
+      } else if (isa<TerminatorInst>(I)) {
+        llvm_unreachable("unhandled value to freeze");
+      } else {
+        FI->insertAfter(I);
+      }
+    } else if (Argument *A = dyn_cast<Argument>(Arg)) {
+      BasicBlock &Entry = F->getEntryBlock();
+      FI = new FreezeInst(Arg, Name, &*Entry.getFirstInsertionPt());
+    } else {
+      llvm_unreachable("unhandled value to freeze");
+    }
+
+    if (replaceAllUses) {
+      Arg->replaceAllUsesWith(FI);
+      FI->replaceUsesOfWith(FI, Arg);
+    }
+    return FI;
+  }
+
   /// \brief Return the i64 difference between two pointer values, dividing out
   /// the size of the pointed-to objects.
   ///
   /// This is intended to implement C-style pointer subtraction. As such, the
   /// pointers must be appropriately aligned for their element types and
   /// pointing into the same object.
   Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") {
     assert(LHS->getType() == RHS->getType() &&

lib/Transforms/Scalar/LoopUnswitch.cpp

 #include "llvm/Analysis/CodeMetrics.h"
 #include "llvm/Analysis/DivergenceAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
private:
     /// Split all of the edges from inside the loop to their exit blocks.
     /// Update the appropriate Phi nodes as we do so.
     void SplitExitEdges(Loop *L,
                         const SmallVectorImpl<BasicBlock *> &ExitBlocks);
 
     bool TryTrivialLoopUnswitch(bool &Changed);
 
     bool UnswitchIfProfitable(Value *LoopCond, Constant *Val,
+                              bool NeedFreeze = true,
                               TerminatorInst *TI = nullptr);
     void UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,
-                                  BasicBlock *ExitBlock, TerminatorInst *TI);
-    void UnswitchNontrivialCondition(Value *LIC, Constant *OnVal, Loop *L,
-                                     TerminatorInst *TI);
+                                  BasicBlock *ExitBlock, bool NeedFreeze,
+    void UnswitchNontrivialCondition(Value *LIC, Constant *OnVal, Loop *L,
+                                     bool NeedFreeze, TerminatorInst *TI);
 
     void RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
                                               Constant *Val, bool isEqual);
 
     void EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
                                         BasicBlock *TrueDest,
                                         BasicBlock *FalseDest,
                                         Instruction *InsertPt,
bool LoopUnswitch::processCurrentLoop() {
   if (OptimizeForSize ||
       loopHeader->getParent()->hasFnAttribute(Attribute::OptimizeForSize))
     return false;
 
   for (IntrinsicInst *Guard : Guards) {
     Value *LoopCond =
         FindLIVLoopCondition(Guard->getOperand(0), currentLoop, Changed).first;
     if (LoopCond &&
-        UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context))) {
+        UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context), true)) {
       // NB! Unswitching (if successful) could have erased some of the
       // instructions in Guards leaving dangling pointers there.  This is fine
       // because we're returning now, and won't look at Guards again.
       ++NumGuards;
       return true;
     }
   }
 
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
       // If this isn't branching on an invariant condition, we can't unswitch
       // it.
       if (BI->isConditional()) {
         // See if this, or some part of it, is loop invariant.  If so, we can
         // unswitch on it if we desire.
         Value *LoopCond = FindLIVLoopCondition(BI->getCondition(),
                                                currentLoop, Changed).first;
         if (LoopCond &&
-            UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context), TI)) {
+            UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context), true, TI)) {
           ++NumBranches;
           return true;
         }
       }
     } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
       Value *SC = SI->getCondition();
       Value *LoopCond;
       OperatorChain OpChain;
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
               break;
             }
           }
         }
 
         if (!UnswitchVal)
           continue;
 
-        if (UnswitchIfProfitable(LoopCond, UnswitchVal)) {
+        if (UnswitchIfProfitable(LoopCond, UnswitchVal, true)) {
           ++NumSwitches;
           // In case of a full LIV, UnswitchVal is the value we unswitched out.
           // In case of a partial LIV, we only unswitch when its an AND-chain
           // or OR-chain. In both cases switch input value simplifies to
           // UnswitchVal.
           BranchesInfo.setUnswitched(SI, UnswitchVal);
           return true;
         }
       }
     }
 
     // Scan the instructions to check for unswitchable values.
     for (BasicBlock::iterator BBI = (*I)->begin(), E = (*I)->end();
          BBI != E; ++BBI)
       if (SelectInst *SI = dyn_cast<SelectInst>(BBI)) {
         Value *LoopCond = FindLIVLoopCondition(SI->getCondition(),
                                                currentLoop, Changed).first;
         if (LoopCond && UnswitchIfProfitable(LoopCond,
-                                             ConstantInt::getTrue(Context))) {
+                                             ConstantInt::getTrue(Context),
+                                             true)) {
           ++NumSelects;
           return true;
         }
       }
   }
   return Changed;
 }
 
if (isTrivialLoopExitBlockHelper(L, BB, ExitBB, Visited))
     return ExitBB;
   return nullptr;
 }
 
 /// We have found that we can unswitch currentLoop when LoopCond == Val to
 /// simplify the loop.  If we decide that this is profitable,
 /// unswitch the loop, reprocess the pieces, then return true.
 bool LoopUnswitch::UnswitchIfProfitable(Value *LoopCond, Constant *Val,
+                                        bool NeedFreeze,
                                         TerminatorInst *TI) {
   // Check to see if it would be profitable to unswitch current loop.
   if (!BranchesInfo.CostAllowsUnswitching()) {
     DEBUG(dbgs() << "NOT unswitching loop %"
                  << currentLoop->getHeader()->getName()
                  << " at non-trivial condition '" << *Val
                  << "' == " << *LoopCond << "\n"
                  << ". Cost too high.\n");
     return false;
   }
   if (hasBranchDivergence &&
       getAnalysis<DivergenceAnalysis>().isDivergent(LoopCond)) {
     DEBUG(dbgs() << "NOT unswitching loop %"
                  << currentLoop->getHeader()->getName()
                  << " at non-trivial condition '" << *Val
                  << "' == " << *LoopCond << "\n"
                  << ". Condition is divergent.\n");
     return false;
   }
 
-  UnswitchNontrivialCondition(LoopCond, Val, currentLoop, TI);
+  UnswitchNontrivialCondition(LoopCond, Val, currentLoop, NeedFreeze, TI);
   return true;
 }
 
 /// Recursively clone the specified loop and all of its children,
 /// mapping the blocks with the specified map.
 static Loop *CloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
                        LoopInfo *LI, LPPassManager *LPM) {
   Loop &New = *new Loop();
void LoopUnswitch::EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
 
   // If either edge is critical, split it. This helps preserve LoopSimplify
   // form for enclosing loops.
   auto Options = CriticalEdgeSplittingOptions(DT, LI).setPreserveLCSSA();
   SplitCriticalEdge(BI, 0, Options);
   SplitCriticalEdge(BI, 1, Options);
 }
 
+static void FreezeBranchCondition(Value *&LIC, BasicBlock *LoopPreheader) {
+  if (isGuaranteedNotToBeUndefOrPoison(LIC))
+    // It is unnecessary to freeze the condition.
+    return;
+
+  IRBuilder<> Builder(LoopPreheader);
+  if (isa<TerminatorInst>(LIC)) {
+    // Terminator with a return value.
+    // Create a freeze instruction, and put it just before the old
+    // branch instruction (in loop preheader)
+    assert (isa<InvokeInst>(LIC) && "Unknown terminator instruction");
+    FreezeInst *FI = new FreezeInst(LIC, LIC->getName() + ".fr");
+    FI->insertBefore(LoopPreheader->getTerminator());
+    LIC = FI;
+  } else {
+    // Put freeze at def of LIC, and replace all uses with the new freeze
+    LIC = Builder.CreateFreezeAtDef(LIC, LoopPreheader->getParent(),
+                                    LIC->getName() + ".fr");
+  }
+}
+
 /// Given a loop that has a trivial unswitchable condition in it (a cond branch
 /// from its header block to its latch block, where the path through the loop
 /// that doesn't execute its body has no side-effects), unswitch it. This
 /// doesn't involve any code duplication, just moving the conditional branch
 /// outside of the loop and updating loop info.
 void LoopUnswitch::UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,
                                             BasicBlock *ExitBlock,
+                                            bool NeedFreeze,
                                             TerminatorInst *TI) {
   DEBUG(dbgs() << "loop-unswitch: Trivial-Unswitch loop %"
                << loopHeader->getName() << " [" << L->getBlocks().size()
                << " blocks] in Function "
                << L->getHeader()->getParent()->getName() << " on cond: " << *Val
                << " == " << *Cond << "\n");
 
   // First step, split the preheader, so that we know that there is a safe place
   // to insert the conditional branch.  We will change loopPreheader to have a
   // conditional branch on Cond.
   BasicBlock *NewPH = SplitEdge(loopPreheader, loopHeader, DT, LI);
 
   // Now that we have a place to insert the conditional branch, create a place
   // to branch to: this is the exit block out of the loop that we should
   // short-circuit to.
 
   // Split this block now, so that the loop maintains its exit block, and so
   // that the jump from the preheader can execute the contents of the exit block
   // without actually branching to it (the exit block should be dominated by the
   // loop header, not the preheader).
   assert(!L->contains(ExitBlock) && "Exit block is in the loop?");
   BasicBlock *NewExit = SplitBlock(ExitBlock, &ExitBlock->front(), DT, LI);
 
+  // If necessary, freeze the branch condition so it does not introduce UB.
+  if (NeedFreeze)
+    FreezeBranchCondition(Cond, loopPreheader);
+
   // Okay, now we have a position to branch from and a position to branch to,
   // insert the new conditional branch.
   EmitPreheaderBranchOnCondition(Cond, Val, NewExit, NewPH,
                                  loopPreheader->getTerminator(), TI);
   LPM->deleteSimpleAnalysisValue(loopPreheader->getTerminator(), L);
   loopPreheader->getTerminator()->eraseFromParent();
 
   // We need to reprocess this loop, it could be unswitched again.
if (BranchInst *BI = dyn_cast<BranchInst>(CurrentTerm)) {
     }
 
     // If we didn't find a single unique LoopExit block, or if the loop exit
     // block contains phi nodes, this isn't trivial.
     if (!LoopExitBB || isa<PHINode>(LoopExitBB->begin()))
       return false;   // Can't handle this.
 
     UnswitchTrivialCondition(currentLoop, LoopCond, CondVal, LoopExitBB,
-                             CurrentTerm);
+                             true, CurrentTerm);
     ++NumBranches;
     return true;
   } else if (SwitchInst *SI = dyn_cast<SwitchInst>(CurrentTerm)) {
     // If this isn't switching on an invariant condition, we can't unswitch it.
     Value *LoopCond = FindLIVLoopCondition(SI->getCondition(),
                                            currentLoop, Changed).first;
 
     // Unswitch only if the trivial condition itself is an LIV (not
if (BranchInst *BI = dyn_cast<BranchInst>(CurrentTerm)) {
     }
 
     // If we didn't find a single unique LoopExit block, or if the loop exit
     // block contains phi nodes, this isn't trivial.
     if (!LoopExitBB || isa<PHINode>(LoopExitBB->begin()))
       return false;   // Can't handle this.
 
     UnswitchTrivialCondition(currentLoop, LoopCond, CondVal, LoopExitBB,
-                             nullptr);
+                             true, nullptr);
 
     // We are only unswitching full LIV.
     BranchesInfo.setUnswitched(SI, CondVal);
     ++NumSwitches;
     return true;
   }
   return false;
 }
SplitBlockPredecessors(ExitBlock, Preds, ".us-lcssa", DT, LI,
                            /*PreserveLCSSA*/ true);
   }
 }
 
 /// We determined that the loop is profitable to unswitch when LIC equal Val.
 /// Split it into loop versions and test the condition outside of either loop.
 /// Return the loops created as Out1/Out2.
 void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
-                                               Loop *L, TerminatorInst *TI) {
+                                               Loop *L, bool NeedFreeze,
+                                               TerminatorInst *TI) {
   Function *F = loopHeader->getParent();
   DEBUG(dbgs() << "loop-unswitch: Unswitching loop %"
         << loopHeader->getName() << " [" << L->getBlocks().size()
         << " blocks] in Function " << F->getName()
         << " when '" << *Val << "' == " << *LIC << "\n");
 
   if (auto *SEWP = getAnalysisIfAvailable<ScalarEvolutionWrapperPass>())
     SEWP->getSE().forgetLoop(L);
for (unsigned i = 0, e = NewBlocks.size(); i != e; ++i) {
     }
   }
 
   // Rewrite the original preheader to select between versions of the loop.
   BranchInst *OldBR = cast<BranchInst>(loopPreheader->getTerminator());
   assert(OldBR->isUnconditional() && OldBR->getSuccessor(0) == LoopBlocks[0] &&
          "Preheader splitting did not work correctly!");
 
+  // If necessary, freeze the branch condition so it does not introduce UB.
+  if (NeedFreeze)
+    FreezeBranchCondition(LIC, loopPreheader);
+
   // Emit the new branch that selects between the two versions of this loop.
   EmitPreheaderBranchOnCondition(LIC, Val, NewBlocks[0], LoopBlocks[0], OldBR,
                                  TI);
   LPM->deleteSimpleAnalysisValue(OldBR, L);
   OldBR->eraseFromParent();
 
   LoopProcessWorklist.push_back(NewLoop);
   redoLoop = true;

test/Transforms/LoopUnswitch/2011-11-18-SimpleSwitch.ll

 ; REQUIRES: asserts
 ; RUN: opt -loop-unswitch -disable-output -stats -info-output-file - < %s | FileCheck --check-prefix=STATS %s
 ; RUN: opt -S -loop-unswitch -verify-loop-info -verify-dom-info < %s | FileCheck %s
 
 ; STATS: 2 loop-unswitch - Number of switches unswitched
 
-; CHECK:      %1 = icmp eq i32 %c, 1
+; CHECK:      %c.fr = freeze i32 %c
+; CHECK-NEXT: %1 = icmp eq i32 %c.fr, 1
 ; CHECK-NEXT: br i1 %1, label %.split.us, label %..split_crit_edge
 
 ; CHECK:      ..split_crit_edge:                                ; preds = %0
 ; CHECK-NEXT:   br label %.split
 
 ; CHECK:      .split.us:                                        ; preds = %0
 ; CHECK-NEXT:   br label %loop_begin.us
 
 ; CHECK:      loop_begin.us:                                    ; preds = %loop_begin.backedge.us, %.split.us
 ; CHECK-NEXT:   %var_val.us = load i32, i32* %var
 ; CHECK-NEXT:   switch i32 1, label %default.us-lcssa.us [
 ; CHECK-NEXT:     i32 1, label %inc.us
 
 ; CHECK:      inc.us:                                           ; preds = %loop_begin.us
 ; CHECK-NEXT:   call void @incf() [[NOR_NUW:#[0-9]+]]
 ; CHECK-NEXT:   br label %loop_begin.backedge.us
 
 ; CHECK:      .split:                                           ; preds = %..split_crit_edge
-; CHECK-NEXT:   %2 = icmp eq i32 %c, 2
+; CHECK-NEXT:   %2 = icmp eq i32 %c.fr, 2
 ; CHECK-NEXT:   br i1 %2, label %.split.split.us, label %.split..split.split_crit_edge
 
 ; CHECK:      .split..split.split_crit_edge:                    ; preds = %.split
 ; CHECK-NEXT:   br label %.split.split
 
 ; CHECK:      .split.split.us:                                  ; preds = %.split
 ; CHECK-NEXT:   br label %loop_begin.us1
 
 ; CHECK:      loop_begin.us1:                                   ; preds = %loop_begin.backedge.us5, %.split.split.us
 ; CHECK-NEXT:   %var_val.us2 = load i32, i32* %var
 ; CHECK-NEXT:   switch i32 2, label %default.us-lcssa.us-lcssa.us [
 ; CHECK-NEXT:     i32 1, label %inc.us4
 ; CHECK-NEXT:     i32 2, label %dec.us3
 ; CHECK-NEXT:   ]
 
 ; CHECK:      dec.us3:                                          ; preds = %loop_begin.us1
 ; CHECK-NEXT:   call void @decf() [[NOR_NUW]]
 ; CHECK-NEXT:   br label %loop_begin.backedge.us5
 
 ; CHECK:      .split.split:                                     ; preds = %.split..split.split_crit_edge
 ; CHECK-NEXT:   br label %loop_begin
 
 ; CHECK:      loop_begin:                                       ; preds = %loop_begin.backedge, %.split.split
 ; CHECK-NEXT:   %var_val = load i32, i32* %var
-; CHECK-NEXT:   switch i32 %c, label %default.us-lcssa.us-lcssa [
+; CHECK-NEXT:   switch i32 %c.fr, label %default.us-lcssa.us-lcssa [
 ; CHECK-NEXT:     i32 1, label %inc
 ; CHECK-NEXT:     i32 2, label %dec
 ; CHECK-NEXT:   ]
 
 ; CHECK:      inc:                                              ; preds = %loop_begin
 ; CHECK-NEXT:   br i1 true, label %us-unreachable.us-lcssa, label %inc.split
 
 ; CHECK:      dec:                                              ; preds = %loop_begin

test/Transforms/LoopUnswitch/2011-11-18-TwoSwitches-Threshold.ll

 ; REQUIRES: asserts
 ; RUN: opt -loop-unswitch -loop-unswitch-threshold 13 -disable-output -stats -info-output-file - < %s | FileCheck --check-prefix=STATS %s
 ; RUN: opt -S -loop-unswitch -loop-unswitch-threshold 13 -verify-loop-info -verify-dom-info < %s | FileCheck %s
 
 ; STATS: 1 loop-unswitch - Number of switches unswitched
 
 ; ModuleID = '../llvm/test/Transforms/LoopUnswitch/2011-11-18-TwoSwitches.ll'
 
-; CHECK:        %1 = icmp eq i32 %c, 1
+; CHECK:        %c.fr = freeze i32 %c
+
+; CHECK:        %1 = icmp eq i32 %c.fr, 1
 ; CHECK-NEXT:   br i1 %1, label %.split.us, label %..split_crit_edge
 
 ; CHECK:      ..split_crit_edge:                                ; preds = %0
 ; CHECK-NEXT:   br label %.split
 
 ; CHECK:      .split.us:                                        ; preds = %0
 ; CHECK-NEXT:   br label %loop_begin.us
 

 ; CHECK:      inc.us:                                           ; preds = %second_switch.us, %loop_begin.us
 ; CHECK-NEXT:   call void @incf() [[NOR_NUW:#[0-9]+]]
 ; CHECK-NEXT:   br label %loop_begin.backedge.us
 
 ; CHECK:      .split:                                           ; preds = %..split_crit_edge
 ; CHECK-NEXT:   br label %loop_begin
 
 ; CHECK:      loop_begin:                                       ; preds = %loop_begin.backedge, %.split
-; CHECK:        switch i32 %c, label %second_switch [
+; CHECK:        switch i32 %c.fr, label %second_switch [
 ; CHECK-NEXT:     i32 1, label %loop_begin.inc_crit_edge
 ; CHECK-NEXT:   ]
 
 ; CHECK:      loop_begin.inc_crit_edge:                         ; preds = %loop_begin
 ; CHECK-NEXT:   br i1 true, label %us-unreachable, label %inc
 
 ; CHECK:      second_switch:                                    ; preds = %loop_begin
 ; CHECK-NEXT:   switch i32 %d, label %default [

test/Transforms/LoopUnswitch/2011-11-18-TwoSwitches.ll

 ; REQUIRES: asserts
 ; RUN: opt -loop-unswitch -loop-unswitch-threshold 1000 -disable-output -stats -info-output-file - < %s | FileCheck --check-prefix=STATS %s
 ; RUN: opt -S -loop-unswitch -loop-unswitch-threshold 1000 -verify-loop-info -verify-dom-info < %s | FileCheck %s
 
 ; STATS: 3 loop-unswitch - Number of switches unswitched
 
-; CHECK:        %1 = icmp eq i32 %c, 1
+; CHECK:        %c.fr = freeze i32 %c
+
+; CHECK:        %d.fr = freeze i32 %d
+; CHECK-NEXT:   %1 = icmp eq i32 %c.fr, 1
 ; CHECK-NEXT:   br i1 %1, label %.split.us, label %..split_crit_edge
 
 ; CHECK:      ..split_crit_edge:                                ; preds = %0
 ; CHECK-NEXT:   br label %.split
 
 ; CHECK:      .split.us:                                        ; preds = %0
-; CHECK-NEXT:   %2 = icmp eq i32 %d, 1
+; CHECK-NEXT:   %2 = icmp eq i32 %d.fr, 1
 ; CHECK-NEXT:   br i1 %2, label %.split.us.split.us, label %.split.us..split.us.split_crit_edge
 
 ; CHECK:      .split.us..split.us.split_crit_edge:              ; preds = %.split.us
 ; CHECK-NEXT:   br label %.split.us.split
 
 ; CHECK:      .split.us.split.us:                               ; preds = %.split.us
 ; CHECK-NEXT:   br label %loop_begin.us.us
 

 ; CHECK-NEXT:   br label %loop_begin.us
 
 ; CHECK:      loop_begin.us:                                    ; preds = %loop_begin.backedge.us, %.split.us.split
 ; CHECK-NEXT:   %var_val.us = load i32, i32* %var
 ; CHECK-NEXT:   switch i32 1, label %second_switch.us [
 ; CHECK-NEXT:     i32 1, label %inc.us
 
 ; CHECK:      second_switch.us:                                 ; preds = %loop_begin.us
-; CHECK-NEXT:   switch i32 %d, label %default.us [
+; CHECK-NEXT:   switch i32 %d.fr, label %default.us [
 ; CHECK-NEXT:     i32 1, label %second_switch.us.inc.us_crit_edge
 ; CHECK-NEXT:   ]
 
 ; CHECK:      second_switch.us.inc.us_crit_edge:                ; preds = %second_switch.us
 ; CHECK-NEXT:   br i1 true, label %us-unreachable8, label %inc.us
 
 ; CHECK:      inc.us:                                           ; preds = %second_switch.us.inc.us_crit_edge, %loop_begin.us
 ; CHECK-NEXT:   call void @incf() [[NOR_NUW]]
 ; CHECK-NEXT:   br label %loop_begin.backedge.us
 
 ; CHECK:      .split:                                           ; preds = %..split_crit_edge
-; CHECK-NEXT:   %3 = icmp eq i32 %d, 1
+; CHECK-NEXT:   %3 = icmp eq i32 %d.fr, 1
 ; CHECK-NEXT:   br i1 %3, label %.split.split.us, label %.split..split.split_crit_edge
 
 ; CHECK:      .split..split.split_crit_edge:                    ; preds = %.split
 ; CHECK-NEXT:   br label %.split.split
 
 ; CHECK:      .split.split.us:                                  ; preds = %.split
 ; CHECK-NEXT:   br label %loop_begin.us1
 
 ; CHECK:      loop_begin.us1:                                   ; preds = %loop_begin.backedge.us6, %.split.split.us
 ; CHECK-NEXT:   %var_val.us2 = load i32, i32* %var
-; CHECK-NEXT:   switch i32 %c, label %second_switch.us3 [
+; CHECK-NEXT:   switch i32 %c.fr, label %second_switch.us3 [
 ; CHECK-NEXT:     i32 1, label %loop_begin.inc_crit_edge.us
 ; CHECK-NEXT:   ]
 
 ; CHECK:      second_switch.us3:                                ; preds = %loop_begin.us1
 ; CHECK-NEXT:   switch i32 1, label %default.us5 [
 ; CHECK-NEXT:     i32 1, label %inc.us4
 ; CHECK-NEXT:   ]
 
 ; CHECK:      inc.us4:                                          ; preds = %loop_begin.inc_crit_edge.us, %second_switch.us3
 ; CHECK-NEXT:   call void @incf() [[NOR_NUW]]
 ; CHECK-NEXT:   br label %loop_begin.backedge.us6
 
 ; CHECK:      loop_begin.inc_crit_edge.us:                      ; preds = %loop_begin.us1
 ; CHECK-NEXT:   br i1 true, label %us-unreachable.us-lcssa.us, label %inc.us4
 
 ; CHECK:      .split.split:                                     ; preds = %.split..split.split_crit_edge
 ; CHECK-NEXT:   br label %loop_begin
 
 ; CHECK:      loop_begin:                                       ; preds = %loop_begin.backedge, %.split.split
 ; CHECK-NEXT:   %var_val = load i32, i32* %var
-; CHECK-NEXT:   switch i32 %c, label %second_switch [
+; CHECK-NEXT:   switch i32 %c.fr, label %second_switch [
 ; CHECK-NEXT:     i32 1, label %loop_begin.inc_crit_edge
 ; CHECK-NEXT:   ]
 
 ; CHECK:      loop_begin.inc_crit_edge:                         ; preds = %loop_begin
 ; CHECK-NEXT:   br i1 true, label %us-unreachable.us-lcssa, label %inc
 
 ; CHECK:      second_switch:                                    ; preds = %loop_begin
-; CHECK-NEXT:   switch i32 %d, label %default [
+; CHECK-NEXT:   switch i32 %d.fr, label %default [
 ; CHECK-NEXT:     i32 1, label %second_switch.inc_crit_edge
 ; CHECK-NEXT:   ]
 
 ; CHECK:      second_switch.inc_crit_edge:                      ; preds = %second_switch
 ; CHECK-NEXT:   br i1 true, label %us-unreachable7, label %inc
 
 
 define i32 @test(i32* %var) {

test/Transforms/LoopUnswitch/2015-06-17-Metadata.ll

 
 for.body:                                         ; preds = %for.inc, %for.body.lr.ph
   %inc.i = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
   %mul.i = phi i32 [ 3, %for.body.lr.ph ], [ %mul.p, %for.inc ]
   %add.i = phi i32 [ %a, %for.body.lr.ph ], [ %add.p, %for.inc ]
   %cmp1 = icmp eq i32 %a, 12345
   br i1 %cmp1, label %if.then, label %if.else, !prof !0
 ; CHECK: %cmp1 = icmp eq i32 %a, 12345
-; CHECK-NEXT: br i1 %cmp1, label %for.body.us, label %for.body, !prof !0
+; CHECK-NEXT: %cmp1.fr = freeze i1 %cmp1
+; CHECK-NEXT: br i1 %cmp1.fr, label %for.body.us, label %for.body, !prof !0
 if.then:                                          ; preds = %for.body
 ; CHECK: for.body.us:
 ; CHECK: add nsw i32 %{{.*}}, 123
 ; CHECK: %exitcond.us = icmp eq i32 %inc.us, %b
 ; CHECK: br i1 %exitcond.us, label %for.cond.cleanup, label %for.body.us
   %add = add nsw i32 %add.i, 123
   br label %for.inc
 

 }
 
 define void @foo_swapped(i32 %a, i32 %b) {
 ;CHECK-LABEL: foo_swapped
 entry:
   br label %for.body
 ;CHECK: entry:
 ;CHECK-NEXT: %cmp1 = icmp eq i32 1, 2
-;CHECK-NEXT: br i1 %cmp1, label %for.body, label %for.cond.cleanup.split, !prof !1
+;CHECK-NEXT: %cmp1.fr = freeze i1 %cmp1
+;CHECK-NEXT: br i1 %cmp1.fr, label %for.body, label %for.cond.cleanup.split, !prof !1
 ;CHECK: for.body:
 for.body:                                         ; preds = %for.inc, %entry
   %inc.i = phi i32 [ 0, %entry ], [ %inc, %if.then ]
   %add.i = phi i32 [ 100, %entry ], [ %add, %if.then ]
   %inc = add nuw nsw i32 %inc.i, 1
   %cmp1 = icmp eq i32 1, 2
   br i1 %cmp1, label %if.then, label  %for.cond.cleanup, !prof !0
 

test/Transforms/LoopUnswitch/AMDGPU/divergent-unswitch.ll

 ; RUN: opt -mtriple=amdgcn-- -O3 -S %s | FileCheck %s
 
 ; Check that loop unswitch happened and condition hoisted out of the loop.
 ; Condition is uniform so all targets should perform unswitching.
 
 ; CHECK-LABEL: {{^}}define amdgpu_kernel void @uniform_unswitch
 ; CHECK: entry:
 ; CHECK-NEXT: [[LOOP_COND:%[a-z0-9]+]] = icmp
+; CHECK-NEXT: br i1 [[LOOP_COND]]
+; CHECK: for.body.lr.ph:
 ; CHECK-NEXT: [[IF_COND:%[a-z0-9]+]] = icmp eq i32 %x, 123456
-; CHECK-NEXT: and i1 [[LOOP_COND]], [[IF_COND]]
-; CHECK-NEXT: br i1
+; CHECK-NEXT: [[IF_COND]].fr = freeze i1 [[IF_COND]]
+; CHECK-NEXT: br i1 [[IF_COND]]
 
 define amdgpu_kernel void @uniform_unswitch(i32 * nocapture %out, i32 %n, i32 %x) {
 entry:
   %cmp6 = icmp sgt i32 %n, 0
   br i1 %cmp6, label %for.body.lr.ph, label %for.cond.cleanup
 
 for.body.lr.ph:                                   ; preds = %entry
   %cmp1 = icmp eq i32 %x, 123456

test/Transforms/LoopUnswitch/basictest.ll

 ; CHECK: }
 }
 
 ; Make sure we unswitch %a == 0 out of the loop.
 ;
 ; CHECK: define void @and_i2_as_switch_input(i2
 ; CHECK: entry:
 ; This is an indication that the loop has been unswitched.
-; CHECK: icmp eq i2 %a, 0
+; CHECK: freeze i2 %a
+; CHECK: icmp eq i2 %a.fr, 0
 ; CHECK: br
 ; There should be no more unswitching after the 1st unswitch.
 ; CHECK-NOT: icmp eq
 ; CHECK: ret
 define void @and_i2_as_switch_input(i2 %a) {
 entry:
   br label %for.body
 
for.end:
   ret void
 }
 
 ; Make sure we unswitch %a == !0 out of the loop.
 ;
 ; CHECK: define void @or_i2_as_switch_input(i2
 ; CHECK: entry:
 ; This is an indication that the loop has been unswitched.
-; CHECK: icmp eq i2 %a, -1
+; CHECK: freeze i2 %a
+; CHECK: icmp eq i2 %a.fr, -1
 ; CHECK: br
 ; There should be no more unswitching after the 1st unswitch.
 ; CHECK-NOT: icmp eq
 ; CHECK: ret
 define void @or_i2_as_switch_input(i2 %a) {
 entry:
   br label %for.body
 

 
 ; Make sure we unswitch %a == !0 out of the loop. Even we do not
 ; have it as a case value. Unswitching it out allows us to simplify
 ; the or operator chain.
 ;
 ; CHECK: define void @or_i2_as_switch_input_unswitch_default(i2
 ; CHECK: entry:
 ; This is an indication that the loop has been unswitched.
-; CHECK: icmp eq i2 %a, -1
+; CHECK: freeze i2 %a
+; CHECK: icmp eq i2 %a.fr, -1
 ; CHECK: br
 ; There should be no more unswitching after the 1st unswitch.
 ; CHECK-NOT: icmp eq
 ; CHECK: ret
 define void @or_i2_as_switch_input_unswitch_default(i2 %a) {
 entry:
   br label %for.body
 

test/Transforms/LoopUnswitch/copy-metadata.ll

 ; RUN: opt < %s -loop-unswitch -S < %s 2>&1 | FileCheck %s
 
 ; This test checks if unswitched condition preserve make.implicit metadata.
 
 define i32 @test(i1 %cond) {
 ; CHECK-LABEL: @test(
-; CHECK:  br i1 %cond, label %..split_crit_edge, label %.loop_exit.split_crit_edge, !make.implicit !0
+; CHECK: %cond.fr = freeze i1 %cond
+; CHECK: br i1 %cond.fr, label %..split_crit_edge, label %.loop_exit.split_crit_edge, !make.implicit !0
   br label %loop_begin
 
 loop_begin:
   br i1 %cond, label %continue, label %loop_exit, !make.implicit !0
 
 continue:
   call void @some_func()
   br label %loop_begin
 
 loop_exit:
   ret i32 0
 }
 
 declare void @some_func()
 
 !0 = !{}

test/Transforms/LoopUnswitch/freeze.ll

+; 6 test cases which must introduce a freeze instruction after loop unswitch
+; RUN: opt < %s -loop-simplify -loop-rotate -loop-unswitch -S | FileCheck %s
+
+@x = common global i32 0, align 4
+define i32 @emptyf()  {
+entry:
+  ret i32 0
+}
+declare i32 @g(i32) 
+declare i32 @h(i32) 
+
+; int f_freeze1(int a, int b){
+;   int sum = 0;
+;   for(int i = 0; i < a; i++){
+;     g(0);
+;     if(b == 0){
+;       sum += g(i);
+;     }
+;     sum++;
+;   }
+;   return sum;
+; }
+
+; CHECK: define i32 @f_freeze1(i32 %a, i32 %b) {
+define i32 @f_freeze1(i32 %a, i32 %b)  {
+entry:
+  br label %for.cond
+
+; CHECK:       %cmp1 = icmp eq i32 %b, 0
+; CHECK-NEXT:  %cmp1.fr = freeze i1 %cmp1
+; CHECK-NEXT:  br i1 %cmp1.fr, label %for.body.lr.ph.split.us, label %for.body.lr.ph.for.body.lr.ph.split_crit_edge
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %sum.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc3, %for.inc ]
+  %cmp = icmp slt i32 %i.0, %a
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %call = call i32 @g(i32 0)
+  %cmp1 = icmp eq i32 %b, 0
+  br i1 %cmp1, label %if.then, label %if.end
+
+if.then:                                          ; preds = %for.body
+  %call2 = call i32 @g(i32 %i.0)
+  %add = add nsw i32 %sum.0, %call2
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %for.body
+  %sum.1 = phi i32 [ %add, %if.then ], [ %sum.0, %for.body ]
+  %inc = add nsw i32 %sum.1, 1
+  br label %for.inc
+
+for.inc:                                          ; preds = %if.end
+  %inc3 = add nsw i32 %i.0, 1
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret i32 %sum.0
+}
+
+; int f_freeze2(int a, int b){
+;   int sum = 0;
+;   for(int i = 0; i < a; i++){
+;     g(0);
+;     if(b == 0){
+;       sum += g(i);
+;     }else{
+;       sum += h(i);
+;     }
+;   }
+;   return sum;
+; }
+
+; CHECK: define i32 @f_freeze2(i32 %a, i32 %b) {
+define i32 @f_freeze2(i32 %a, i32 %b)  {
+entry:
+  br label %for.cond
+
+; CHECK:       %cmp1 = icmp eq i32 %b, 0
+; CHECK-NEXT:  %cmp1.fr = freeze i1 %cmp1
+; CHECK-NEXT:  br i1 %cmp1.fr, label %for.body.lr.ph.split.us, label %for.body.lr.ph.for.body.lr.ph.split_crit_edge
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %sum.0 = phi i32 [ 0, %entry ], [ %sum.1, %for.inc ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
+  %cmp = icmp slt i32 %i.0, %a
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %call = call i32 @g(i32 0)
+  %cmp1 = icmp eq i32 %b, 0
+  br i1 %cmp1, label %if.then, label %if.else
+
+if.then:                                          ; preds = %for.body
+  %call2 = call i32 @g(i32 %i.0)
+  %add = add nsw i32 %sum.0, %call2
+  br label %if.end
+
+if.else:                                          ; preds = %for.body
+  %call3 = call i32 @h(i32 %i.0)
+  %add4 = add nsw i32 %sum.0, %call3
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+  %sum.1 = phi i32 [ %add, %if.then ], [ %add4, %if.else ]
+  br label %for.inc
+
+for.inc:                                          ; preds = %if.end
+  %inc = add nsw i32 %i.0, 1
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret i32 %sum.0
+}
+
+
+; int f_freeze3(int a, int b){
+;   int sum = 0;
+;   for(int i = 0; i < a; i++){
+;     if(x == 0) {
+;       emptyf();
+;     }
+;     // Unswitching the below branch
+;     if(b == 0){
+;       sum += g(i);
+;     }
+;     sum++;
+;   }
+;   return sum;
+; }
+
+; CHECK: define i32 @f_freeze3(i32 %a, i32 %b) {
+define i32 @f_freeze3(i32 %a, i32 %b)  {
+entry:
+  br label %for.cond
+
+; CHECK:       %cmp2 = icmp eq i32 %b, 0
+; CHECK-NEXT:  %cmp2.fr = freeze i1 %cmp2
+; CHECK-NEXT:  br i1 %cmp2.fr, label %for.body.lr.ph.split.us, label %for.body.lr.ph.for.body.lr.ph.split_crit_edge
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %sum.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc6, %for.inc ]
+  %cmp = icmp slt i32 %i.0, %a
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %0 = load i32, i32* @x, align 4
+  %cmp1 = icmp eq i32 %0, 0
+  br i1 %cmp1, label %if.then, label %if.end
+
+if.then:                                          ; preds = %for.body
+  %call = call i32 @emptyf()
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %for.body
+  %cmp2 = icmp eq i32 %b, 0
+  br i1 %cmp2, label %if.then3, label %if.end5
+
+if.then3:                                         ; preds = %if.end
+  %call4 = call i32 @g(i32 %i.0)
+  %add = add nsw i32 %sum.0, %call4
+  br label %if.end5
+
+if.end5:                                          ; preds = %if.then3, %if.end
+  %sum.1 = phi i32 [ %add, %if.then3 ], [ %sum.0, %if.end ]
+  %inc = add nsw i32 %sum.1, 1
+  br label %for.inc
+
+for.inc:                                          ; preds = %if.end5
+  %inc6 = add nsw i32 %i.0, 1
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret i32 %sum.0
+}
+
+; int f_freeze4(int a, int b){
+;   int sum = 0;
+;   for(int i = 0; i < a; i++){
+;     if(x == 0) {
+;       emptyf();
+;     }
+;     // Unswitching the below branch
+;     if(b == 0){
+;       sum += g(i);
+;     }else{
+;       sum += h(i);
+;     }
+;   }
+;   return sum;
+; }
+
+; CHECK: define i32 @f_freeze4(i32 %a, i32 %b) {
+define i32 @f_freeze4(i32 %a, i32 %b)  {
+entry:
+  br label %for.cond
+
+; CHECK:       %cmp2 = icmp eq i32 %b, 0
+; CHECK-NEXT:  %cmp2.fr = freeze i1 %cmp2
+; CHECK-NEXT:  br i1 %cmp2.fr, label %for.body.lr.ph.split.us, label %for.body.lr.ph.for.body.lr.ph.split_crit_edge
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %sum.0 = phi i32 [ 0, %entry ], [ %sum.1, %for.inc ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
+  %cmp = icmp slt i32 %i.0, %a
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %0 = load i32, i32* @x, align 4
+  %cmp1 = icmp eq i32 %0, 0
+  br i1 %cmp1, label %if.then, label %if.end
+
+if.then:                                          ; preds = %for.body
+  %call = call i32 @emptyf()
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %for.body
+  %cmp2 = icmp eq i32 %b, 0
+  br i1 %cmp2, label %if.then3, label %if.else
+
+if.then3:                                         ; preds = %if.end
+  %call4 = call i32 @g(i32 %i.0)
+  %add = add nsw i32 %sum.0, %call4
+  br label %if.end7
+
+if.else:                                          ; preds = %if.end
+  %call5 = call i32 @h(i32 %i.0)
+  %add6 = add nsw i32 %sum.0, %call5
+  br label %if.end7
+
+if.end7:                                          ; preds = %if.else, %if.then3
+  %sum.1 = phi i32 [ %add, %if.then3 ], [ %add6, %if.else ]
+  br label %for.inc
+
+for.inc:                                          ; preds = %if.end7
+  %inc = add nsw i32 %i.0, 1
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret i32 %sum.0
+}
+
+; int f_freeze5(int a, int b){
+;   int sum = 0;
+;   for(int i = 0; i < a; i++){
+;     sum++;
+;     if(b == 0){
+;       sum += g(i);
+;     }
+;   }
+;   return sum;
+; }
+
+; CHECK: define i32 @f_freeze5(i32 %a, i32 %b) {
+define i32 @f_freeze5(i32 %a, i32 %b)  {
+entry:
+  br label %for.cond
+
+; CHECK: %cmp1 = icmp eq i32 %b, 0
+; CHECK-NEXT: %cmp1.fr = freeze i1 %cmp1
+; CHECK-NEXT: br i1 %cmp1.fr, label %for.body.lr.ph.split.us, label %for.body.lr.ph.for.body.lr.ph.split_crit_edge
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %sum.0 = phi i32 [ 0, %entry ], [ %sum.1, %for.inc ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc2, %for.inc ]
+  %cmp = icmp slt i32 %i.0, %a
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %inc = add nsw i32 %sum.0, 1
+  %cmp1 = icmp eq i32 %b, 0
+  br i1 %cmp1, label %if.then, label %if.end
+
+if.then:                                          ; preds = %for.body
+  %call = call i32 @g(i32 %i.0)
+  %add = add nsw i32 %inc, %call
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %for.body
+  %sum.1 = phi i32 [ %add, %if.then ], [ %inc, %for.body ]
+  br label %for.inc
+
+for.inc:                                          ; preds = %if.end
+  %inc2 = add nsw i32 %i.0, 1
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret i32 %sum.0
+}
+
+; int f_freeze6(int a, int b){
+;   int sum = 0;
+;   for(int i = 0; i < a; i++){
+;     sum++;
+;     if(b == 0){
+;       sum += g(i);
+;     }else{
+;       sum += h(i);
+;     }
+;   }
+;   return sum;
+; }
+
+; CHECK: define i32 @f_freeze6(i32 %a, i32 %b) {
+define i32 @f_freeze6(i32 %a, i32 %b)  {
+entry:
+  br label %for.cond
+
+; CHECK: %cmp1 = icmp eq i32 %b, 0
+; CHECK-NEXT: %cmp1.fr = freeze i1 %cmp1
+; CHECK-NEXT: br i1 %cmp1.fr, label %for.body.lr.ph.split.us, label %for.body.lr.ph.for.body.lr.ph.split_crit_edge
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %sum.0 = phi i32 [ 0, %entry ], [ %sum.1, %for.inc ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc4, %for.inc ]
+  %cmp = icmp slt i32 %i.0, %a
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %inc = add nsw i32 %sum.0, 1
+  %cmp1 = icmp eq i32 %b, 0
+  br i1 %cmp1, label %if.then, label %if.else
+
+if.then:                                          ; preds = %for.body
+  %call = call i32 @g(i32 %i.0)
+  %add = add nsw i32 %inc, %call
+  br label %if.end
+
+if.else:                                          ; preds = %for.body
+  %call2 = call i32 @h(i32 %i.0)
+  %add3 = add nsw i32 %inc, %call2
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+  %sum.1 = phi i32 [ %add, %if.then ], [ %add3, %if.else ]
+  br label %for.inc
+
+for.inc:                                          ; preds = %if.end
+  %inc4 = add nsw i32 %i.0, 1
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  ret i32 %sum.0
+}
+
+

test/Transforms/LoopUnswitch/infinite-loop.ll

 ; REQUIRES: asserts
 ; RUN: opt -loop-unswitch -disable-output -stats -info-output-file - < %s | FileCheck --check-prefix=STATS %s
 ; RUN: opt -loop-unswitch -simplifycfg -S < %s | FileCheck %s
 ; PR5373
 
 ; Loop unswitching shouldn't trivially unswitch the true case of condition %a
 ; in the code here because it leads to an infinite loop. While this doesn't
 ; contain any instructions with side effects, it's still a kind of side effect.
 ; It can trivially unswitch on the false cas of condition %a though.
 
 ; STATS: 2 loop-unswitch - Number of branches unswitched
 ; STATS: 2 loop-unswitch - Number of unswitches that are trivial
 
 ; CHECK-LABEL: @func_16(
 ; CHECK-NEXT: entry:
-; CHECK-NEXT: br i1 %a, label %entry.split, label %abort0.split
+; CHECK-NEXT: %b.fr = freeze i1 %b
+; CHECK-NEXT: %a.fr = freeze i1 %a
+; CHECK-NEXT: br i1 %a.fr, label %entry.split, label %abort0.split
 
 ; CHECK: entry.split:
-; CHECK-NEXT: br i1 %b, label %for.body, label %abort1.split
+; CHECK-NEXT: br i1 %b.fr, label %for.body, label %abort1.split
 
 ; CHECK: for.body:
 ; CHECK-NEXT: br label %for.body
 
 ; CHECK: abort0.split:
 ; CHECK-NEXT: call void @end0() [[NOR_NUW:#[0-9]+]]
 ; CHECK-NEXT: unreachable
 

test/Transforms/LoopUnswitch/msan.ll

 ; }
 ; "if (y)" is guaranteed to execute; the loop can be unswitched.
 
 define void @must_execute(i1 zeroext %x, i32 %p, i32 %q) sanitize_memory {
 ; CHECK-LABEL: @must_execute(
 entry:
 ; CHECK:       %[[Y:.*]] = load i64, i64* @y, align 8
 ; CHECK-NEXT:  %[[YB:.*]] = icmp eq i64 %[[Y]], 0
-; CHECK-NEXT:  br i1 %[[YB]],
+; CHECK-NEXT:  %[[YB]].fr = freeze i1 %[[YB]]
+; CHECK-NEXT:  br i1 %[[YB]].fr,
 
   %x2 = alloca i8, align 1
   %frombool1 = zext i1 %x to i8
   store volatile i8 %frombool1, i8* %x2, align 1
   %0 = load i64, i64* @y, align 8
   %tobool2 = icmp eq i64 %0, 0
   br label %for.body
 

test/Transforms/LoopUnswitch/trivial-unswitch.ll

 ; RUN: opt < %s -loop-unswitch -loop-unswitch-threshold=0 -verify-loop-info -S < %s 2>&1 | FileCheck %s
 
 ; This test contains two trivial unswitch condition in one loop. 
 ; LoopUnswitch pass should be able to unswitch the second one 
 ; after unswitching the first one.
 
 
-; CHECK:  br i1 %cond1, label %..split_crit_edge, label %.loop_exit.split_crit_edge
+; CHECK:  %cond2.fr = freeze i1 %cond2
+; CHECK:  %cond1.fr = freeze i1 %cond1
+; CHECK:  br i1 %cond1.fr, label %..split_crit_edge, label %.loop_exit.split_crit_edge
 
 ; CHECK:  ..split_crit_edge:                                ; preds = %0
 ; CHECK:    br label %.split
 
 ; CHECK:  .split:                                           ; preds = %..split_crit_edge
-; CHECK:    br i1 %cond2, label %.split..split.split_crit_edge, label %.split.loop_exit.split1_crit_edge
+; CHECK:    br i1 %cond2.fr, label %.split..split.split_crit_edge, label %.split.loop_exit.split1_crit_edge
 
 ; CHECK:  .split..split.split_crit_edge:                    ; preds = %.split
 ; CHECK:    br label %.split.split
 
 ; CHECK:  .split.split:                                     ; preds = %.split..split.split_crit_edge
 ; CHECK:    br label %loop_begin
 
 ; CHECK:  loop_begin:                                       ; preds = %do_something, %.split.split

 
 ; We will not be able trivially unswitch on the SwitchInst, as its input
 ; is a constant. However, since its a constant we should be able to figure
 ; out that the switch can be folded into a unconditional branch to %continue.
 ; Then we unswitch on the br inst in %continue.
 ;
 ; CHECK: define i32 @test2(
 ; This is an indication that the loop has been unswitched on %cond1.
-; CHECK:  br i1 %cond1, label %..split_crit_edge, label %.loop_exit.split_crit_edge
+; CHECK:  %cond1.fr = freeze i1 %cond
+; CHECK:  br i1 %cond1.fr, label %..split_crit_edge, label %.loop_exit.split_crit_edge
 
 ; CHECK:  ..split_crit_edge:                                ; preds = %0
 ; CHECK:    br label %.split
 
 ; CHECK:  .split:                                           ; preds = %..split_crit_edge
 ; CHECK:    br label %loop_begin
 
 ; CHECK:  loop_begin:                                       ; preds = %do_something, %.split