Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 282 insertions, 282 deletions

diff --git a/contrib/libs/llvm12/lib/Transforms/Scalar/LoopUnswitch.cpp b/contrib/libs/llvm12/lib/Transforms/Scalar/LoopUnswitch.cpp
index 843be6cbb9..822a786fc7 100644
--- a/contrib/libs/llvm12/lib/Transforms/Scalar/LoopUnswitch.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/Scalar/LoopUnswitch.cpp
@@ -32,7 +32,7 @@
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/CodeMetrics.h"
 #include "llvm/Analysis/InstructionSimplify.h"
-#include "llvm/Analysis/LazyBlockFrequencyInfo.h" 
+#include "llvm/Analysis/LazyBlockFrequencyInfo.h"
 #include "llvm/Analysis/LegacyDivergenceAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/LoopIterator.h"
@@ -99,12 +99,12 @@ static cl::opt<unsigned>
 Threshold("loop-unswitch-threshold", cl::desc("Max loop size to unswitch"),
           cl::init(100), cl::Hidden);
 
-static cl::opt<unsigned> 
-    MSSAThreshold("loop-unswitch-memoryssa-threshold", 
-                  cl::desc("Max number of memory uses to explore during " 
-                           "partial unswitching analysis"), 
-                  cl::init(100), cl::Hidden); 
- 
+static cl::opt<unsigned>
+    MSSAThreshold("loop-unswitch-memoryssa-threshold",
+                  cl::desc("Max number of memory uses to explore during "
+                           "partial unswitching analysis"),
+                  cl::init(100), cl::Hidden);
+
 namespace {
 
   class LUAnalysisCache {
@@ -191,7 +191,7 @@ namespace {
     Loop *CurrentLoop = nullptr;
     DominatorTree *DT = nullptr;
     MemorySSA *MSSA = nullptr;
-    AAResults *AA = nullptr; 
+    AAResults *AA = nullptr;
     std::unique_ptr<MemorySSAUpdater> MSSAU;
     BasicBlock *LoopHeader = nullptr;
     BasicBlock *LoopPreheader = nullptr;
@@ -225,10 +225,10 @@ namespace {
     /// loop preheaders be inserted into the CFG.
     ///
     void getAnalysisUsage(AnalysisUsage &AU) const override {
-      // Lazy BFI and BPI are marked as preserved here so Loop Unswitching 
-      // can remain part of the same loop pass as LICM 
-      AU.addPreserved<LazyBlockFrequencyInfoPass>(); 
-      AU.addPreserved<LazyBranchProbabilityInfoPass>(); 
+      // Lazy BFI and BPI are marked as preserved here so Loop Unswitching
+      // can remain part of the same loop pass as LICM
+      AU.addPreserved<LazyBlockFrequencyInfoPass>();
+      AU.addPreserved<LazyBranchProbabilityInfoPass>();
       AU.addRequired<AssumptionCacheTracker>();
       AU.addRequired<TargetTransformInfoWrapperPass>();
       if (EnableMSSALoopDependency) {
@@ -256,22 +256,22 @@ namespace {
     bool tryTrivialLoopUnswitch(bool &Changed);
 
     bool unswitchIfProfitable(Value *LoopCond, Constant *Val,
-                              Instruction *TI = nullptr, 
-                              ArrayRef<Instruction *> ToDuplicate = {}); 
+                              Instruction *TI = nullptr,
+                              ArrayRef<Instruction *> ToDuplicate = {});
     void unswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,
                                   BasicBlock *ExitBlock, Instruction *TI);
     void unswitchNontrivialCondition(Value *LIC, Constant *OnVal, Loop *L,
-                                     Instruction *TI, 
-                                     ArrayRef<Instruction *> ToDuplicate = {}); 
+                                     Instruction *TI,
+                                     ArrayRef<Instruction *> ToDuplicate = {});
 
     void rewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
                                               Constant *Val, bool IsEqual);
 
-    void 
-    emitPreheaderBranchOnCondition(Value *LIC, Constant *Val, 
-                                   BasicBlock *TrueDest, BasicBlock *FalseDest, 
-                                   BranchInst *OldBranch, Instruction *TI, 
-                                   ArrayRef<Instruction *> ToDuplicate = {}); 
+    void
+    emitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
+                                   BasicBlock *TrueDest, BasicBlock *FalseDest,
+                                   BranchInst *OldBranch, Instruction *TI,
+                                   ArrayRef<Instruction *> ToDuplicate = {});
 
     void simplifyCode(std::vector<Instruction *> &Worklist, Loop *L);
 
@@ -538,7 +538,7 @@ bool LoopUnswitch::runOnLoop(Loop *L, LPPassManager &LPMRef) {
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   LPM = &LPMRef;
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-  AA = &getAnalysis<AAResultsWrapperPass>().getAAResults(); 
+  AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
   if (EnableMSSALoopDependency) {
     MSSA = &getAnalysis<MemorySSAWrapperPass>().getMSSA();
     MSSAU = std::make_unique<MemorySSAUpdater>(MSSA);
@@ -640,145 +640,145 @@ static bool equalityPropUnSafe(Value &LoopCond) {
   return false;
 }
 
-/// Check if the loop header has a conditional branch that is not 
-/// loop-invariant, because it involves load instructions. If all paths from 
-/// either the true or false successor to the header or loop exists do not 
-/// modify the memory feeding the condition, perform 'partial unswitching'. That 
-/// is, duplicate the instructions feeding the condition in the pre-header. Then 
-/// unswitch on the duplicated condition. The condition is now known in the 
-/// unswitched version for the 'invariant' path through the original loop. 
-/// 
-/// If the branch condition of the header is partially invariant, return a pair 
-/// containing the instructions to duplicate and a boolean Constant to update 
-/// the condition in the loops created for the true or false successors. 
-static std::pair<SmallVector<Instruction *, 4>, Constant *> 
-hasPartialIVCondition(Loop *L, MemorySSA &MSSA, AAResults *AA) { 
-  SmallVector<Instruction *, 4> ToDuplicate; 
- 
-  auto *TI = dyn_cast<BranchInst>(L->getHeader()->getTerminator()); 
-  if (!TI || !TI->isConditional()) 
-    return {}; 
- 
-  auto *CondI = dyn_cast<CmpInst>(TI->getCondition()); 
-  // The case with the condition outside the loop should already be handled 
-  // earlier. 
-  if (!CondI || !L->contains(CondI)) 
-    return {}; 
- 
-  ToDuplicate.push_back(CondI); 
- 
-  SmallVector<Value *, 4> WorkList; 
-  WorkList.append(CondI->op_begin(), CondI->op_end()); 
- 
-  SmallVector<MemoryAccess *, 4> AccessesToCheck; 
-  SmallVector<MemoryLocation, 4> AccessedLocs; 
-  while (!WorkList.empty()) { 
-    Instruction *I = dyn_cast<Instruction>(WorkList.pop_back_val()); 
-    if (!I || !L->contains(I)) 
-      continue; 
- 
-    // TODO: support additional instructions. 
-    if (!isa<LoadInst>(I) && !isa<GetElementPtrInst>(I)) 
-      return {}; 
- 
-    // Do not duplicate volatile and atomic loads. 
-    if (auto *LI = dyn_cast<LoadInst>(I)) 
-      if (LI->isVolatile() || LI->isAtomic()) 
-        return {}; 
- 
-    ToDuplicate.push_back(I); 
-    if (MemoryAccess *MA = MSSA.getMemoryAccess(I)) { 
-      if (auto *MemUse = dyn_cast_or_null<MemoryUse>(MA)) { 
-        // Queue the defining access to check for alias checks. 
-        AccessesToCheck.push_back(MemUse->getDefiningAccess()); 
-        AccessedLocs.push_back(MemoryLocation::get(I)); 
-      } else { 
-        // MemoryDefs may clobber the location or may be atomic memory 
-        // operations. Bail out. 
-        return {}; 
-      } 
-    } 
-    WorkList.append(I->op_begin(), I->op_end()); 
-  } 
- 
-  if (ToDuplicate.size() <= 1) 
-    return {}; 
- 
-  auto HasNoClobbersOnPath = 
-      [L, AA, &AccessedLocs](BasicBlock *Succ, BasicBlock *Header, 
-                             SmallVector<MemoryAccess *, 4> AccessesToCheck) { 
-        // First, collect all blocks in the loop that are on a patch from Succ 
-        // to the header. 
-        SmallVector<BasicBlock *, 4> WorkList; 
-        WorkList.push_back(Succ); 
-        WorkList.push_back(Header); 
-        SmallPtrSet<BasicBlock *, 4> Seen; 
-        Seen.insert(Header); 
-        while (!WorkList.empty()) { 
-          BasicBlock *Current = WorkList.pop_back_val(); 
-          if (!L->contains(Current)) 
-            continue; 
-          const auto &SeenIns = Seen.insert(Current); 
-          if (!SeenIns.second) 
-            continue; 
- 
-          WorkList.append(succ_begin(Current), succ_end(Current)); 
-        } 
- 
-        // Require at least 2 blocks on a path through the loop. This skips 
-        // paths that directly exit the loop. 
-        if (Seen.size() < 2) 
-          return false; 
- 
-        // Next, check if there are any MemoryDefs that are on the path through 
-        // the loop (in the Seen set) and they may-alias any of the locations in 
-        // AccessedLocs. If that is the case, they may modify the condition and 
-        // partial unswitching is not possible. 
-        SmallPtrSet<MemoryAccess *, 4> SeenAccesses; 
-        while (!AccessesToCheck.empty()) { 
-          MemoryAccess *Current = AccessesToCheck.pop_back_val(); 
-          auto SeenI = SeenAccesses.insert(Current); 
-          if (!SeenI.second || !Seen.contains(Current->getBlock())) 
-            continue; 
- 
-          // Bail out if exceeded the threshold. 
-          if (SeenAccesses.size() >= MSSAThreshold) 
-            return false; 
- 
-          // MemoryUse are read-only accesses. 
-          if (isa<MemoryUse>(Current)) 
-            continue; 
- 
-          // For a MemoryDef, check if is aliases any of the location feeding 
-          // the original condition. 
-          if (auto *CurrentDef = dyn_cast<MemoryDef>(Current)) { 
-            if (any_of(AccessedLocs, [AA, CurrentDef](MemoryLocation &Loc) { 
-                  return isModSet( 
-                      AA->getModRefInfo(CurrentDef->getMemoryInst(), Loc)); 
-                })) 
-              return false; 
-          } 
- 
-          for (Use &U : Current->uses()) 
-            AccessesToCheck.push_back(cast<MemoryAccess>(U.getUser())); 
-        } 
- 
-        return true; 
-      }; 
- 
-  // If we branch to the same successor, partial unswitching will not be 
-  // beneficial. 
-  if (TI->getSuccessor(0) == TI->getSuccessor(1)) 
-    return {}; 
- 
-  if (HasNoClobbersOnPath(TI->getSuccessor(0), L->getHeader(), AccessesToCheck)) 
-    return {ToDuplicate, ConstantInt::getTrue(TI->getContext())}; 
-  if (HasNoClobbersOnPath(TI->getSuccessor(1), L->getHeader(), AccessesToCheck)) 
-    return {ToDuplicate, ConstantInt::getFalse(TI->getContext())}; 
- 
-  return {}; 
-} 
- 
+/// Check if the loop header has a conditional branch that is not
+/// loop-invariant, because it involves load instructions. If all paths from
+/// either the true or false successor to the header or loop exists do not
+/// modify the memory feeding the condition, perform 'partial unswitching'. That
+/// is, duplicate the instructions feeding the condition in the pre-header. Then
+/// unswitch on the duplicated condition. The condition is now known in the
+/// unswitched version for the 'invariant' path through the original loop.
+///
+/// If the branch condition of the header is partially invariant, return a pair
+/// containing the instructions to duplicate and a boolean Constant to update
+/// the condition in the loops created for the true or false successors.
+static std::pair<SmallVector<Instruction *, 4>, Constant *>
+hasPartialIVCondition(Loop *L, MemorySSA &MSSA, AAResults *AA) {
+  SmallVector<Instruction *, 4> ToDuplicate;
+
+  auto *TI = dyn_cast<BranchInst>(L->getHeader()->getTerminator());
+  if (!TI || !TI->isConditional())
+    return {};
+
+  auto *CondI = dyn_cast<CmpInst>(TI->getCondition());
+  // The case with the condition outside the loop should already be handled
+  // earlier.
+  if (!CondI || !L->contains(CondI))
+    return {};
+
+  ToDuplicate.push_back(CondI);
+
+  SmallVector<Value *, 4> WorkList;
+  WorkList.append(CondI->op_begin(), CondI->op_end());
+
+  SmallVector<MemoryAccess *, 4> AccessesToCheck;
+  SmallVector<MemoryLocation, 4> AccessedLocs;
+  while (!WorkList.empty()) {
+    Instruction *I = dyn_cast<Instruction>(WorkList.pop_back_val());
+    if (!I || !L->contains(I))
+      continue;
+
+    // TODO: support additional instructions.
+    if (!isa<LoadInst>(I) && !isa<GetElementPtrInst>(I))
+      return {};
+
+    // Do not duplicate volatile and atomic loads.
+    if (auto *LI = dyn_cast<LoadInst>(I))
+      if (LI->isVolatile() || LI->isAtomic())
+        return {};
+
+    ToDuplicate.push_back(I);
+    if (MemoryAccess *MA = MSSA.getMemoryAccess(I)) {
+      if (auto *MemUse = dyn_cast_or_null<MemoryUse>(MA)) {
+        // Queue the defining access to check for alias checks.
+        AccessesToCheck.push_back(MemUse->getDefiningAccess());
+        AccessedLocs.push_back(MemoryLocation::get(I));
+      } else {
+        // MemoryDefs may clobber the location or may be atomic memory
+        // operations. Bail out.
+        return {};
+      }
+    }
+    WorkList.append(I->op_begin(), I->op_end());
+  }
+
+  if (ToDuplicate.size() <= 1)
+    return {};
+
+  auto HasNoClobbersOnPath =
+      [L, AA, &AccessedLocs](BasicBlock *Succ, BasicBlock *Header,
+                             SmallVector<MemoryAccess *, 4> AccessesToCheck) {
+        // First, collect all blocks in the loop that are on a patch from Succ
+        // to the header.
+        SmallVector<BasicBlock *, 4> WorkList;
+        WorkList.push_back(Succ);
+        WorkList.push_back(Header);
+        SmallPtrSet<BasicBlock *, 4> Seen;
+        Seen.insert(Header);
+        while (!WorkList.empty()) {
+          BasicBlock *Current = WorkList.pop_back_val();
+          if (!L->contains(Current))
+            continue;
+          const auto &SeenIns = Seen.insert(Current);
+          if (!SeenIns.second)
+            continue;
+
+          WorkList.append(succ_begin(Current), succ_end(Current));
+        }
+
+        // Require at least 2 blocks on a path through the loop. This skips
+        // paths that directly exit the loop.
+        if (Seen.size() < 2)
+          return false;
+
+        // Next, check if there are any MemoryDefs that are on the path through
+        // the loop (in the Seen set) and they may-alias any of the locations in
+        // AccessedLocs. If that is the case, they may modify the condition and
+        // partial unswitching is not possible.
+        SmallPtrSet<MemoryAccess *, 4> SeenAccesses;
+        while (!AccessesToCheck.empty()) {
+          MemoryAccess *Current = AccessesToCheck.pop_back_val();
+          auto SeenI = SeenAccesses.insert(Current);
+          if (!SeenI.second || !Seen.contains(Current->getBlock()))
+            continue;
+
+          // Bail out if exceeded the threshold.
+          if (SeenAccesses.size() >= MSSAThreshold)
+            return false;
+
+          // MemoryUse are read-only accesses.
+          if (isa<MemoryUse>(Current))
+            continue;
+
+          // For a MemoryDef, check if is aliases any of the location feeding
+          // the original condition.
+          if (auto *CurrentDef = dyn_cast<MemoryDef>(Current)) {
+            if (any_of(AccessedLocs, [AA, CurrentDef](MemoryLocation &Loc) {
+                  return isModSet(
+                      AA->getModRefInfo(CurrentDef->getMemoryInst(), Loc));
+                }))
+              return false;
+          }
+
+          for (Use &U : Current->uses())
+            AccessesToCheck.push_back(cast<MemoryAccess>(U.getUser()));
+        }
+
+        return true;
+      };
+
+  // If we branch to the same successor, partial unswitching will not be
+  // beneficial.
+  if (TI->getSuccessor(0) == TI->getSuccessor(1))
+    return {};
+
+  if (HasNoClobbersOnPath(TI->getSuccessor(0), L->getHeader(), AccessesToCheck))
+    return {ToDuplicate, ConstantInt::getTrue(TI->getContext())};
+  if (HasNoClobbersOnPath(TI->getSuccessor(1), L->getHeader(), AccessesToCheck))
+    return {ToDuplicate, ConstantInt::getFalse(TI->getContext())};
+
+  return {};
+}
+
 /// Do actual work and unswitch loop if possible and profitable.
 bool LoopUnswitch::processCurrentLoop() {
   bool Changed = false;
@@ -816,7 +816,7 @@ bool LoopUnswitch::processCurrentLoop() {
   // FIXME: Use Function::hasOptSize().
   if (OptimizeForSize ||
       LoopHeader->getParent()->hasFnAttribute(Attribute::OptimizeForSize))
-    return Changed; 
+    return Changed;
 
   // Run through the instructions in the loop, keeping track of three things:
   //
@@ -840,10 +840,10 @@ bool LoopUnswitch::processCurrentLoop() {
       if (!CB)
         continue;
       if (CB->isConvergent())
-        return Changed; 
+        return Changed;
       if (auto *II = dyn_cast<InvokeInst>(&I))
         if (!II->getUnwindDest()->canSplitPredecessors())
-          return Changed; 
+          return Changed;
       if (auto *II = dyn_cast<IntrinsicInst>(&I))
         if (II->getIntrinsicID() == Intrinsic::experimental_guard)
           Guards.push_back(II);
@@ -978,28 +978,28 @@ bool LoopUnswitch::processCurrentLoop() {
         }
       }
   }
- 
-  // Check if there is a header condition that is invariant along the patch from 
-  // either the true or false successors to the header. This allows unswitching 
-  // conditions depending on memory accesses, if there's a path not clobbering 
-  // the memory locations. Check if this transform has been disabled using 
-  // metadata, to avoid unswitching the same loop multiple times. 
-  if (MSSA && 
-      !findOptionMDForLoop(CurrentLoop, "llvm.loop.unswitch.partial.disable")) { 
-    auto ToDuplicate = hasPartialIVCondition(CurrentLoop, *MSSA, AA); 
-    if (!ToDuplicate.first.empty()) { 
-      LLVM_DEBUG(dbgs() << "loop-unswitch: Found partially invariant condition " 
-                        << *ToDuplicate.first[0] << "\n"); 
-      ++NumBranches; 
-      unswitchIfProfitable(ToDuplicate.first[0], ToDuplicate.second, 
-                           CurrentLoop->getHeader()->getTerminator(), 
-                           ToDuplicate.first); 
- 
-      RedoLoop = false; 
-      return true; 
-    } 
-  } 
- 
+
+  // Check if there is a header condition that is invariant along the patch from
+  // either the true or false successors to the header. This allows unswitching
+  // conditions depending on memory accesses, if there's a path not clobbering
+  // the memory locations. Check if this transform has been disabled using
+  // metadata, to avoid unswitching the same loop multiple times.
+  if (MSSA &&
+      !findOptionMDForLoop(CurrentLoop, "llvm.loop.unswitch.partial.disable")) {
+    auto ToDuplicate = hasPartialIVCondition(CurrentLoop, *MSSA, AA);
+    if (!ToDuplicate.first.empty()) {
+      LLVM_DEBUG(dbgs() << "loop-unswitch: Found partially invariant condition "
+                        << *ToDuplicate.first[0] << "\n");
+      ++NumBranches;
+      unswitchIfProfitable(ToDuplicate.first[0], ToDuplicate.second,
+                           CurrentLoop->getHeader()->getTerminator(),
+                           ToDuplicate.first);
+
+      RedoLoop = false;
+      return true;
+    }
+  }
+
   return Changed;
 }
 
@@ -1057,8 +1057,8 @@ static BasicBlock *isTrivialLoopExitBlock(Loop *L, BasicBlock *BB) {
 /// 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,
-                                        Instruction *TI, 
-                                        ArrayRef<Instruction *> ToDuplicate) { 
+                                        Instruction *TI,
+                                        ArrayRef<Instruction *> ToDuplicate) {
   // Check to see if it would be profitable to unswitch current loop.
   if (!BranchesInfo.costAllowsUnswitching()) {
     LLVM_DEBUG(dbgs() << "NOT unswitching loop %"
@@ -1078,69 +1078,69 @@ bool LoopUnswitch::unswitchIfProfitable(Value *LoopCond, Constant *Val,
     return false;
   }
 
-  unswitchNontrivialCondition(LoopCond, Val, CurrentLoop, TI, ToDuplicate); 
+  unswitchNontrivialCondition(LoopCond, Val, CurrentLoop, TI, ToDuplicate);
   return true;
 }
 
 /// Emit a conditional branch on two values if LIC == Val, branch to TrueDst,
 /// otherwise branch to FalseDest. Insert the code immediately before OldBranch
 /// and remove (but not erase!) it from the function.
-void LoopUnswitch::emitPreheaderBranchOnCondition( 
-    Value *LIC, Constant *Val, BasicBlock *TrueDest, BasicBlock *FalseDest, 
-    BranchInst *OldBranch, Instruction *TI, 
-    ArrayRef<Instruction *> ToDuplicate) { 
+void LoopUnswitch::emitPreheaderBranchOnCondition(
+    Value *LIC, Constant *Val, BasicBlock *TrueDest, BasicBlock *FalseDest,
+    BranchInst *OldBranch, Instruction *TI,
+    ArrayRef<Instruction *> ToDuplicate) {
   assert(OldBranch->isUnconditional() && "Preheader is not split correctly");
   assert(TrueDest != FalseDest && "Branch targets should be different");
- 
+
   // Insert a conditional branch on LIC to the two preheaders.  The original
   // code is the true version and the new code is the false version.
   Value *BranchVal = LIC;
   bool Swapped = false;
- 
-  if (!ToDuplicate.empty()) { 
-    ValueToValueMapTy Old2New; 
-    for (Instruction *I : reverse(ToDuplicate)) { 
-      auto *New = I->clone(); 
-      New->insertBefore(OldBranch); 
-      RemapInstruction(New, Old2New, 
-                       RF_NoModuleLevelChanges | RF_IgnoreMissingLocals); 
-      Old2New[I] = New; 
- 
-      if (MSSAU) { 
-        MemorySSA *MSSA = MSSAU->getMemorySSA(); 
-        auto *MemA = dyn_cast_or_null<MemoryUse>(MSSA->getMemoryAccess(I)); 
-        if (!MemA) 
-          continue; 
- 
-        Loop *L = LI->getLoopFor(I->getParent()); 
-        auto *DefiningAccess = MemA->getDefiningAccess(); 
-        // Get the first defining access before the loop. 
-        while (L->contains(DefiningAccess->getBlock())) { 
-          // If the defining access is a MemoryPhi, get the incoming 
-          // value for the pre-header as defining access. 
-          if (auto *MemPhi = dyn_cast<MemoryPhi>(DefiningAccess)) { 
-            DefiningAccess = 
-                MemPhi->getIncomingValueForBlock(L->getLoopPreheader()); 
-          } else { 
-            DefiningAccess = 
-                cast<MemoryDef>(DefiningAccess)->getDefiningAccess(); 
-          } 
-        } 
-        MSSAU->createMemoryAccessInBB(New, DefiningAccess, New->getParent(), 
-                                      MemorySSA::BeforeTerminator); 
-      } 
-    } 
-    BranchVal = Old2New[ToDuplicate[0]]; 
-  } else { 
- 
-    if (!isa<ConstantInt>(Val) || 
-        Val->getType() != Type::getInt1Ty(LIC->getContext())) 
-      BranchVal = new ICmpInst(OldBranch, ICmpInst::ICMP_EQ, LIC, Val); 
-    else if (Val != ConstantInt::getTrue(Val->getContext())) { 
-      // We want to enter the new loop when the condition is true. 
-      std::swap(TrueDest, FalseDest); 
-      Swapped = true; 
-    } 
+
+  if (!ToDuplicate.empty()) {
+    ValueToValueMapTy Old2New;
+    for (Instruction *I : reverse(ToDuplicate)) {
+      auto *New = I->clone();
+      New->insertBefore(OldBranch);
+      RemapInstruction(New, Old2New,
+                       RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
+      Old2New[I] = New;
+
+      if (MSSAU) {
+        MemorySSA *MSSA = MSSAU->getMemorySSA();
+        auto *MemA = dyn_cast_or_null<MemoryUse>(MSSA->getMemoryAccess(I));
+        if (!MemA)
+          continue;
+
+        Loop *L = LI->getLoopFor(I->getParent());
+        auto *DefiningAccess = MemA->getDefiningAccess();
+        // Get the first defining access before the loop.
+        while (L->contains(DefiningAccess->getBlock())) {
+          // If the defining access is a MemoryPhi, get the incoming
+          // value for the pre-header as defining access.
+          if (auto *MemPhi = dyn_cast<MemoryPhi>(DefiningAccess)) {
+            DefiningAccess =
+                MemPhi->getIncomingValueForBlock(L->getLoopPreheader());
+          } else {
+            DefiningAccess =
+                cast<MemoryDef>(DefiningAccess)->getDefiningAccess();
+          }
+        }
+        MSSAU->createMemoryAccessInBB(New, DefiningAccess, New->getParent(),
+                                      MemorySSA::BeforeTerminator);
+      }
+    }
+    BranchVal = Old2New[ToDuplicate[0]];
+  } else {
+
+    if (!isa<ConstantInt>(Val) ||
+        Val->getType() != Type::getInt1Ty(LIC->getContext()))
+      BranchVal = new ICmpInst(OldBranch, ICmpInst::ICMP_EQ, LIC, Val);
+    else if (Val != ConstantInt::getTrue(Val->getContext())) {
+      // We want to enter the new loop when the condition is true.
+      std::swap(TrueDest, FalseDest);
+      Swapped = true;
+    }
   }
 
   // Old branch will be removed, so save its parent and successor to update the
@@ -1173,9 +1173,9 @@ void LoopUnswitch::emitPreheaderBranchOnCondition(
     }
 
     if (MSSAU)
-      MSSAU->applyUpdates(Updates, *DT, /*UpdateDT=*/true); 
-    else 
-      DT->applyUpdates(Updates); 
+      MSSAU->applyUpdates(Updates, *DT, /*UpdateDT=*/true);
+    else
+      DT->applyUpdates(Updates);
   }
 
   // If either edge is critical, split it. This helps preserve LoopSimplify
@@ -1424,9 +1424,9 @@ void LoopUnswitch::splitExitEdges(
 /// 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, Instruction *TI, 
-    ArrayRef<Instruction *> ToDuplicate) { 
+void LoopUnswitch::unswitchNontrivialCondition(
+    Value *LIC, Constant *Val, Loop *L, Instruction *TI,
+    ArrayRef<Instruction *> ToDuplicate) {
   Function *F = LoopHeader->getParent();
   LLVM_DEBUG(dbgs() << "loop-unswitch: Unswitching loop %"
                     << LoopHeader->getName() << " [" << L->getBlocks().size()
@@ -1451,7 +1451,7 @@ void LoopUnswitch::unswitchNontrivialCondition(
   LoopBlocks.push_back(NewPreheader);
 
   // We want the loop to come after the preheader, but before the exit blocks.
-  llvm::append_range(LoopBlocks, L->blocks()); 
+  llvm::append_range(LoopBlocks, L->blocks());
 
   SmallVector<BasicBlock*, 8> ExitBlocks;
   L->getUniqueExitBlocks(ExitBlocks);
@@ -1465,7 +1465,7 @@ void LoopUnswitch::unswitchNontrivialCondition(
   L->getUniqueExitBlocks(ExitBlocks);
 
   // Add exit blocks to the loop blocks.
-  llvm::append_range(LoopBlocks, ExitBlocks); 
+  llvm::append_range(LoopBlocks, ExitBlocks);
 
   // Next step, clone all of the basic blocks that make up the loop (including
   // the loop preheader and exit blocks), keeping track of the mapping between
@@ -1558,7 +1558,7 @@ void LoopUnswitch::unswitchNontrivialCondition(
 
   // Emit the new branch that selects between the two versions of this loop.
   emitPreheaderBranchOnCondition(LIC, Val, NewBlocks[0], LoopBlocks[0], OldBR,
-                                 TI, ToDuplicate); 
+                                 TI, ToDuplicate);
   if (MSSAU) {
     // Update MemoryPhis in Exit blocks.
     MSSAU->updateExitBlocksForClonedLoop(ExitBlocks, VMap, *DT);
@@ -1580,39 +1580,39 @@ void LoopUnswitch::unswitchNontrivialCondition(
   // iteration.
   WeakTrackingVH LICHandle(LIC);
 
-  if (ToDuplicate.empty()) { 
-    // Now we rewrite the original code to know that the condition is true and 
-    // the new code to know that the condition is false. 
-    rewriteLoopBodyWithConditionConstant(L, LIC, Val, /*IsEqual=*/false); 
-
-    // It's possible that simplifying one loop could cause the other to be 
-    // changed to another value or a constant.  If its a constant, don't 
-    // simplify it. 
-    if (!LoopProcessWorklist.empty() && LoopProcessWorklist.back() == NewLoop && 
-        LICHandle && !isa<Constant>(LICHandle)) 
-      rewriteLoopBodyWithConditionConstant(NewLoop, LICHandle, Val, 
-                                           /*IsEqual=*/true); 
-  } else { 
-    // Partial unswitching. Update the condition in the right loop with the 
-    // constant. 
-    auto *CC = cast<ConstantInt>(Val); 
-    if (CC->isOneValue()) { 
-      rewriteLoopBodyWithConditionConstant(NewLoop, VMap[LIC], Val, 
-                                           /*IsEqual=*/true); 
-    } else 
-      rewriteLoopBodyWithConditionConstant(L, LIC, Val, /*IsEqual=*/true); 
-
-    // Mark the new loop as partially unswitched, to avoid unswitching on the 
-    // same condition again. 
-    auto &Context = NewLoop->getHeader()->getContext(); 
-    MDNode *DisableUnswitchMD = MDNode::get( 
-        Context, MDString::get(Context, "llvm.loop.unswitch.partial.disable")); 
-    MDNode *NewLoopID = makePostTransformationMetadata( 
-        Context, L->getLoopID(), {"llvm.loop.unswitch.partial"}, 
-        {DisableUnswitchMD}); 
-    NewLoop->setLoopID(NewLoopID); 
-  } 
- 
+  if (ToDuplicate.empty()) {
+    // Now we rewrite the original code to know that the condition is true and
+    // the new code to know that the condition is false.
+    rewriteLoopBodyWithConditionConstant(L, LIC, Val, /*IsEqual=*/false);
+
+    // It's possible that simplifying one loop could cause the other to be
+    // changed to another value or a constant.  If its a constant, don't
+    // simplify it.
+    if (!LoopProcessWorklist.empty() && LoopProcessWorklist.back() == NewLoop &&
+        LICHandle && !isa<Constant>(LICHandle))
+      rewriteLoopBodyWithConditionConstant(NewLoop, LICHandle, Val,
+                                           /*IsEqual=*/true);
+  } else {
+    // Partial unswitching. Update the condition in the right loop with the
+    // constant.
+    auto *CC = cast<ConstantInt>(Val);
+    if (CC->isOneValue()) {
+      rewriteLoopBodyWithConditionConstant(NewLoop, VMap[LIC], Val,
+                                           /*IsEqual=*/true);
+    } else
+      rewriteLoopBodyWithConditionConstant(L, LIC, Val, /*IsEqual=*/true);
+
+    // Mark the new loop as partially unswitched, to avoid unswitching on the
+    // same condition again.
+    auto &Context = NewLoop->getHeader()->getContext();
+    MDNode *DisableUnswitchMD = MDNode::get(
+        Context, MDString::get(Context, "llvm.loop.unswitch.partial.disable"));
+    MDNode *NewLoopID = makePostTransformationMetadata(
+        Context, L->getLoopID(), {"llvm.loop.unswitch.partial"},
+        {DisableUnswitchMD});
+    NewLoop->setLoopID(NewLoopID);
+  }
+
   if (MSSA && VerifyMemorySSA)
     MSSA->verifyMemorySSA();
 }
@@ -1620,7 +1620,7 @@ void LoopUnswitch::unswitchNontrivialCondition(
 /// Remove all instances of I from the worklist vector specified.
 static void removeFromWorklist(Instruction *I,
                                std::vector<Instruction *> &Worklist) {
-  llvm::erase_value(Worklist, I); 
+  llvm::erase_value(Worklist, I);
 }
 
 /// When we find that I really equals V, remove I from the