Preserve domtree and loop-simplify for runtime unrolling.

[efriedma]

Summary

Mostly straightforward changes; we just didn't do the computation before. One sort of interesting change in LoopUnroll.cpp: we weren't handling dominance for children of the loop latch correctly, but foldBlockIntoPredecessor hid the problem for complete unrolling.

Currently punting on loop peeling; made some minor changes to isolate that problem to LoopUnrollPeel.cpp.

Adds a flag -unroll-verify-domtree; this is on by default for +Asserts builds.

[mkuper]

lib/Transforms/Utils/LoopUnroll.cpp

55

We want to enforce this being on in new tests too, I assume?

619

Isn't it the case that when the latch ends with an unconditional branch, that branch is towards the header block?
If so, we should not have any children outside the loop.

[efriedma]

lib/Transforms/Utils/LoopUnroll.cpp

55

We probably want this on in new tests, yes, but I have no idea how we would enforce it.

619

Maybe this is more clear? "The latch is special because we can emit an unconditional branch in the unrolled loop even if the original latch block ends in a conditional branch."

[mkuper]

lib/Transforms/Utils/LoopUnroll.cpp

55

In code review, I meant. :-)

619

Ah, ok, this makes sense.
This still looks a bit weird to me, though. Any chance you can give an example of when this ends up different than the nearest common dominator with Latches[0]?

(Feel free to ignore me - I'm not sure I understand this enough to LGTM it anyway. :-) )

[mzolotukhin]

lib/Transforms/Utils/LoopUnroll.cpp

55

Can we make the default value true for debug builds (it will match the existing behavior)?

619

I'm also curious about an example.

Also, this part is not clear to me: "Since the latch is always at the bottom of the loop, new dominator must also be a latch." Why can't a mid-block from the body be a dominator of a cloned latch?

639–642

Thanks for fixing this!

644–646

Do I understand it correctly that using -verify-dom-info wasn't sufficient because of foldBlockIntoPredecessor, and that's why we're now introducing unroll-verify-domtree?

700–701

Why can we remove this?

[efriedma]

lib/Transforms/Utils/LoopUnroll.cpp

55

Okay. (I initially didn't do this because it's O(N^2) in theory, but it turns out it doesn't really matter that much.)

619

This shows up for example, if you completely unroll a single-block loop with a constant trip count; the immediate dominator of the exit is the last iteration of the loop, not the first iteration. (foldBlockIntoPredecessor hides this problem because the block in question gets folded away when a loop is completely unrolled.)

Why can't a mid-block from the body be a dominator of a cloned latch?

I'm not sure what you're asking here. ChildrenToUpdate is the set of loop exit blocks which are dominated by BB, so this code only touches the idom for blocks outside the loop. The latch's idom isn't relevant.

644–646

Yes... we want to verify at this point to try and catch as many mistakes as possible.

700–701

There are three possibilities for unrolling: we could be completely unrolling a loop, we could be runtime unrolling a loop, or we could be peeling a loop. If we're completely unrolling, these lines are a no-op. If we're runtime unrolling, we now correctly preserve LoopSimplify for L (and we don't break it for any loop outside of L). If we're peeling, we explicitly recreate LoopSimplify earlier.

[mzolotukhin]

lib/Transforms/Utils/LoopUnroll.cpp

55

Thanks! Also, if you change it to true, then changes in the tests are no longer needed.

619

I've just understood what the problem is, thanks! Yes, it all makes sense now.

625–631

I think we should be able to tell which latch ends with a conditional. It should be either the first one (if all latches end with conditional branches), or the last one. Does it make sense? If so, can we remove this loop?

700–701

But isn't it also used for LCSSA? Maybe I'm missing something, but it's still not obvious to me that we can remove it.

[efriedma]

lib/Transforms/Utils/LoopUnroll.cpp

700–701

!CompletelyUnroll implies !NeedToFixLCSSA.

[mzolotukhin]

lib/Transforms/Utils/LoopUnroll.cpp

700–701

Ah, right!

[efriedma]

lib/Transforms/Utils/LoopUnroll.cpp

625–631

The actual conditional is complicated... if we're completely unrolling, it's either the first one or the last one, depending on PreserveCondBr. If we're using a remainder loop, it's always the last one. If we're partially unrolling without a remainder loop, it might not be the first or last one; there's a complicated conditional involving BreakingTrip and TripMultiple. Anyway, this is much more straightforward than trying to duplicate the NeedConditional logic.

[efriedma]

Verify domtree by default in +Asserts mode. Clarify comments.

[mzolotukhin]

Looks good to me, thanks!

Michael

lib/Transforms/Utils/LoopUnroll.cpp

625–631

Makes sense.

include/llvm/Transforms/Utils/UnrollLoop.h

bool UnrollRuntimeLoopRemainder(Loop *L, unsigned Count,
                                 bool UseEpilogRemainder, LoopInfo *LI,
                                 ScalarEvolution *SE, DominatorTree *DT,
                                 bool PreserveLCSSA);
 
 void computePeelCount(Loop *L, unsigned LoopSize,
                       TargetTransformInfo::UnrollingPreferences &UP);
 
 bool peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI, ScalarEvolution *SE,
-              DominatorTree *DT, bool PreserveLCSSA);
+              DominatorTree *DT, AssumptionCache *AC, bool PreserveLCSSA);
 
 MDNode *GetUnrollMetadata(MDNode *LoopID, StringRef Name);
 }
 
 #endif

lib/Transforms/Utils/LoopUnroll.cpp

 STATISTIC(NumCompletelyUnrolled, "Number of loops completely unrolled");
 STATISTIC(NumUnrolled, "Number of loops unrolled (completely or otherwise)");
 
 static cl::opt<bool>
 UnrollRuntimeEpilog("unroll-runtime-epilog", cl::init(false), cl::Hidden,
                     cl::desc("Allow runtime unrolled loops to be unrolled "
                              "with epilog instead of prolog."));
 
+static cl::opt<bool>
+UnrollVerifyDomtree("unroll-verify-domtree", cl::init(false), cl::Hidden,
+                    cl::desc("Verify domtree after unrolling"));
+
 /// Convert the instruction operands from referencing the current values into
 /// those specified by VMap.
 static inline void remapInstruction(Instruction *I,
                                     ValueToValueMapTy &VMap) {
   for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) {
     Value *Op = I->getOperand(op);
     ValueToValueMapTy::iterator It = VMap.find(Op);
     if (It != VMap.end())
bool llvm::UnrollLoop(Loop *L, unsigned Count, unsigned TripCount, bool Force,
   // flag is specified.
   bool RuntimeTripCount = (TripCount == 0 && Count > 0 && AllowRuntime);
 
   assert((!RuntimeTripCount || !PeelCount) &&
          "Did not expect runtime trip-count unrolling "
          "and peeling for the same loop");
 
   if (PeelCount)
-    peelLoop(L, PeelCount, LI, SE, DT, PreserveLCSSA);
+    peelLoop(L, PeelCount, LI, SE, DT, AC, PreserveLCSSA);
 
   // Loops containing convergent instructions must have a count that divides
   // their TripMultiple.
   DEBUG(
       {
         bool HasConvergent = false;
         for (auto &BB : L->blocks())
           for (auto &I : *BB)
if (NeedConditional) {
           }
         }
       }
       // Replace the conditional branch with an unconditional one.
       BranchInst::Create(Dest, Term);
       Term->eraseFromParent();
     }
   }
+
   // Update dominators of blocks we might reach through exits.
   // Immediate dominator of such block might change, because we add more
   // routes which can lead to the exit: we can now reach it from the copied
-  // iterations too. Thus, the new idom of the block will be the nearest
-  // common dominator of the previous idom and common dominator of all copies of
-  // the previous idom. This is equivalent to the nearest common dominator of
-  // the previous idom and the first latch, which dominates all copies of the
-  // previous idom.
+  // iterations too.
   if (DT && Count > 1) {
     for (auto *BB : OriginalLoopBlocks) {
       auto *BBDomNode = DT->getNode(BB);
       SmallVector<BasicBlock *, 16> ChildrenToUpdate;
       for (auto *ChildDomNode : BBDomNode->getChildren()) {
         auto *ChildBB = ChildDomNode->getBlock();
         if (!L->contains(ChildBB))
           ChildrenToUpdate.push_back(ChildBB);
       }
-      BasicBlock *NewIDom = DT->findNearestCommonDominator(BB, Latches[0]);
+      BasicBlock *NewIDom;
+      if (BB == LatchBlock) {
+        // The latch is special because we emit unconditional branches in
+        // some cases.  Since the latch is always at the bottom of the loop,
+        // the new dominator must also be a latch.  Specifically, the dominator
+        // is the first latch which ends in a conditional branch, or the last
+        // latch if there is no such latch.
+        NewIDom = Latches.back();
+        for (BasicBlock *IterLatch : Latches) {
+          TerminatorInst *Term = IterLatch->getTerminator();
+          if (isa<BranchInst>(Term) && cast<BranchInst>(Term)->isConditional()) {
+            NewIDom = IterLatch;
+            break;
+          }
+        }
+      } else {
+        // The new idom of the block will be the nearest common dominator
+        // of all copies of the previous idom. This is equivalent to the
+        // nearest common dominator of the previous idom and the first latch,
+        // which dominates all copies of the previous idom.
+        NewIDom = DT->findNearestCommonDominator(BB, LatchBlock);
+      }
       for (auto *ChildBB : ChildrenToUpdate)
         DT->changeImmediateDominator(ChildBB, NewIDom);
     }
   }
 
+  if (DT && UnrollVerifyDomtree)
+    DT->verifyDomTree();
+
   // Merge adjacent basic blocks, if possible.
   SmallPtrSet<Loop *, 4> ForgottenLoops;
   for (BasicBlock *Latch : Latches) {
     BranchInst *Term = cast<BranchInst>(Latch->getTerminator());
     if (Term->isUnconditional()) {
       BasicBlock *Dest = Term->getSuccessor(0);
       if (BasicBlock *Fold =
               foldBlockIntoPredecessor(Dest, LI, SE, ForgottenLoops, DT)) {
         // Dest has been folded into Fold. Update our worklists accordingly.
         std::replace(Latches.begin(), Latches.end(), Dest, Fold);
         UnrolledLoopBlocks.erase(std::remove(UnrolledLoopBlocks.begin(),
                                              UnrolledLoopBlocks.end(), Dest),
                                  UnrolledLoopBlocks.end());
       }
     }
   }
 
-  // FIXME: We only preserve DT info for complete unrolling now. Incrementally
-  // updating domtree after partial loop unrolling should also be easy.
-  if (DT && !CompletelyUnroll)
-    DT->recalculate(*L->getHeader()->getParent());
-  else if (DT)
-    DEBUG(DT->verifyDomTree());
-
   // Simplify any new induction variables in the partially unrolled loop.
   if (SE && !CompletelyUnroll && Count > 1) {
     SmallVector<WeakVH, 16> DeadInsts;
     simplifyLoopIVs(L, SE, DT, LI, DeadInsts);
 
     // Aggressively clean up dead instructions that simplifyLoopIVs already
     // identified. Any remaining should be cleaned up below.
     while (!DeadInsts.empty())
bool llvm::UnrollLoop(Loop *L, unsigned Count, unsigned TripCount, bool Force,
   if (PreserveLCSSA && OuterL && CompletelyUnroll && !NeedToFixLCSSA)
     NeedToFixLCSSA |= ::needToInsertPhisForLCSSA(OuterL, UnrolledLoopBlocks, LI);
 
   // If we have a pass and a DominatorTree we should re-simplify impacted loops
   // to ensure subsequent analyses can rely on this form. We want to simplify
   // at least one layer outside of the loop that was unrolled so that any
   // changes to the parent loop exposed by the unrolling are considered.
   if (DT) {
-    if (!OuterL && !CompletelyUnroll)
-      OuterL = L;
     if (OuterL) {
       // OuterL includes all loops for which we can break loop-simplify, so
       // it's sufficient to simplify only it (it'll recursively simplify inner
       // loops too).
       // TODO: That potentially might be compile-time expensive. We should try
       // to fix the loop-simplified form incrementally.
       simplifyLoop(OuterL, DT, LI, SE, AC, PreserveLCSSA);
 

lib/Transforms/Utils/LoopUnrollPeel.cpp

 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/LoopSimplify.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/UnrollLoop.h"
 #include <algorithm>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "loop-unroll"
 STATISTIC(NumPeeled, "Number of loops peeled");

 /// Rather, each iteration is peeled off separately, and needs to check the
 /// exit condition.
 /// For loops that dynamically execute \p PeelCount iterations or less
 /// this provides a benefit, since the peeled off iterations, which account
 /// for the bulk of dynamic execution, can be further simplified by scalar
 /// optimizations.
 bool llvm::peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI,
                     ScalarEvolution *SE, DominatorTree *DT,
-                    bool PreserveLCSSA) {
+                    AssumptionCache *AC, bool PreserveLCSSA) {
   if (!canPeel(L))
     return false;
 
   LoopBlocksDFS LoopBlocks(L);
   LoopBlocks.perform(LI);
 
   BasicBlock *Header = L->getHeader();
   BasicBlock *PreHeader = L->getLoopPreheader();
bool llvm::peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI,
   if (ExitWeight) {
     MDBuilder MDB(LatchBR->getContext());
     MDNode *WeightNode =
         HeaderIdx ? MDB.createBranchWeights(ExitWeight, BackEdgeWeight)
                   : MDB.createBranchWeights(BackEdgeWeight, ExitWeight);
     LatchBR->setMetadata(LLVMContext::MD_prof, WeightNode);
   }
 
+  // FIXME: Incrementally update domtree.
+  DT->recalculate(*L->getHeader()->getParent());
+
   // If the loop is nested, we changed the parent loop, update SE.
-  if (Loop *ParentLoop = L->getParentLoop())
+  if (Loop *ParentLoop = L->getParentLoop()) {
     SE->forgetLoop(ParentLoop);
 
+    // FIXME: Incrementally update loop-simplify
+    simplifyLoop(ParentLoop, DT, LI, SE, AC, PreserveLCSSA);
+  } else {
+    // FIXME: Incrementally update loop-simplify
+    simplifyLoop(L, DT, LI, SE, AC, PreserveLCSSA);
+  }
+
   NumPeeled++;
 
   return true;
 }

lib/Transforms/Utils/LoopUnrollRuntime.cpp

static void ConnectProlog(Loop *L, Value *BECount, unsigned Count,
   assert(Exit && "Loop must have a single exit block only");
   // Split the exit to maintain loop canonicalization guarantees
   SmallVector<BasicBlock*, 4> Preds(predecessors(Exit));
   SplitBlockPredecessors(Exit, Preds, ".unr-lcssa", DT, LI,
                          PreserveLCSSA);
   // Add the branch to the exit block (around the unrolled loop)
   B.CreateCondBr(BrLoopExit, Exit, NewPreHeader);
   InsertPt->eraseFromParent();
+  if (DT)
+    DT->changeImmediateDominator(Exit, PrologExit);
 }
 
 /// Connect the unrolling epilog code to the original loop.
 /// The unrolling epilog code contains code to execute the
 /// 'extra' iterations if the run-time trip count modulo the
 /// unroll count is non-zero.
 ///
 /// This function performs the following:
for (Instruction &BBI : *Succ) {
       VPN->setIncomingValue(VPN->getBasicBlockIndex(EpilogPreHeader), NewPN);
     }
   }
 
   Instruction *InsertPt = NewExit->getTerminator();
   IRBuilder<> B(InsertPt);
   Value *BrLoopExit = B.CreateIsNotNull(ModVal, "lcmp.mod");
   assert(Exit && "Loop must have a single exit block only");
-  // Split the exit to maintain loop canonicalization guarantees
+  // Split the epilogue exit to maintain loop canonicalization guarantees
   SmallVector<BasicBlock*, 4> Preds(predecessors(Exit));
   SplitBlockPredecessors(Exit, Preds, ".epilog-lcssa", DT, LI,
                          PreserveLCSSA);
   // Add the branch to the exit block (around the unrolling loop)
   B.CreateCondBr(BrLoopExit, EpilogPreHeader, Exit);
   InsertPt->eraseFromParent();
+  if (DT)
+    DT->changeImmediateDominator(Exit, NewExit);
+
+  // Split the main loop exit to maintain canonicalization guarantees.
+  SmallVector<BasicBlock*, 4> NewExitPreds{Latch};
+  SplitBlockPredecessors(NewExit, NewExitPreds, ".loopexit", DT, LI,
+                         PreserveLCSSA);
 }
 
 /// Create a clone of the blocks in a loop and connect them together.
 /// If CreateRemainderLoop is false, loop structure will not be cloned,
 /// otherwise a new loop will be created including all cloned blocks, and the
 /// iterator of it switches to count NewIter down to 0.
 /// The cloned blocks should be inserted between InsertTop and InsertBot.
 /// If loop structure is cloned InsertTop should be new preheader, InsertBot
 /// new loop exit.
 ///
 static void CloneLoopBlocks(Loop *L, Value *NewIter,
                             const bool CreateRemainderLoop,
                             const bool UseEpilogRemainder,
                             BasicBlock *InsertTop, BasicBlock *InsertBot,
                             BasicBlock *Preheader,
                             std::vector<BasicBlock *> &NewBlocks,
                             LoopBlocksDFS &LoopBlocks, ValueToValueMapTy &VMap,
-                            LoopInfo *LI) {
+                            DominatorTree *DT, LoopInfo *LI) {
   StringRef suffix = UseEpilogRemainder ? "epil" : "prol";
   BasicBlock *Header = L->getHeader();
   BasicBlock *Latch = L->getLoopLatch();
   Function *F = Header->getParent();
   LoopBlocksDFS::RPOIterator BlockBegin = LoopBlocks.beginRPO();
   LoopBlocksDFS::RPOIterator BlockEnd = LoopBlocks.endRPO();
   Loop *NewLoop = nullptr;
   Loop *ParentLoop = L->getParentLoop();
if (Latch == *BB) {
         Builder.CreateCondBr(IdxCmp, FirstLoopBB, InsertBot);
         NewIdx->addIncoming(NewIter, InsertTop);
         NewIdx->addIncoming(IdxSub, NewBB);
       }
       LatchBR->eraseFromParent();
     }
   }
 
+  if (DT) {
+    for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) {
+      BasicBlock *NewBB = cast<BasicBlock>(VMap[*BB]);
+      if (Header == *BB) {
+        // The header is dominated by the preheader.
+        DT->addNewBlock(NewBB, InsertTop);
+      } else {
+        // Copy information from original loop to unrolled loop.
+        BasicBlock *IDomBB = DT->getNode(*BB)->getIDom()->getBlock();
+        DT->addNewBlock(NewBB, cast<BasicBlock>(VMap[IDomBB]));
+      }
+    }
+  }
+
   // Change the incoming values to the ones defined in the preheader or
   // cloned loop.
   for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
     PHINode *NewPHI = cast<PHINode>(VMap[&*I]);
     if (!CreateRemainderLoop) {
       if (UseEpilogRemainder) {
         unsigned idx = NewPHI->getBasicBlockIndex(Preheader);
         NewPHI->setIncomingBlock(idx, InsertTop);
Value *BranchVal =
                                            ConstantInt::get(BECount->getType(),
                                                             Count - 1)) :
                            B.CreateIsNotNull(ModVal, "lcmp.mod");
   BasicBlock *RemainderLoop = UseEpilogRemainder ? NewExit : PrologPreHeader;
   BasicBlock *UnrollingLoop = UseEpilogRemainder ? NewPreHeader : PrologExit;
   // Branch to either remainder (extra iterations) loop or unrolling loop.
   B.CreateCondBr(BranchVal, RemainderLoop, UnrollingLoop);
   PreHeaderBR->eraseFromParent();
+  if (DT) {
+    if (UseEpilogRemainder)
+      DT->changeImmediateDominator(NewExit, PreHeader);
+    else
+      DT->changeImmediateDominator(PrologExit, PreHeader);
+  }
   Function *F = Header->getParent();
   // Get an ordered list of blocks in the loop to help with the ordering of the
   // cloned blocks in the prolog/epilog code
   LoopBlocksDFS LoopBlocks(L);
   LoopBlocks.perform(LI);
 
   //
   // For each extra loop iteration, create a copy of the loop's basic blocks
   // and generate a condition that branches to the copy depending on the
   // number of 'left over' iterations.
   //
   std::vector<BasicBlock *> NewBlocks;
   ValueToValueMapTy VMap;
 
   // For unroll factor 2 remainder loop will have 1 iterations.
   // Do not create 1 iteration loop.
   bool CreateRemainderLoop = (Count != 2);
 
   // Clone all the basic blocks in the loop. If Count is 2, we don't clone
   // the loop, otherwise we create a cloned loop to execute the extra
   // iterations. This function adds the appropriate CFG connections.
   BasicBlock *InsertBot = UseEpilogRemainder ? Exit : PrologExit;
   BasicBlock *InsertTop = UseEpilogRemainder ? EpilogPreHeader : PrologPreHeader;
   CloneLoopBlocks(L, ModVal, CreateRemainderLoop, UseEpilogRemainder, InsertTop,
-                  InsertBot, NewPreHeader, NewBlocks, LoopBlocks, VMap, LI);
+                  InsertBot, NewPreHeader, NewBlocks, LoopBlocks, VMap, DT, LI);
 
   // Insert the cloned blocks into the function.
   F->getBasicBlockList().splice(InsertBot->getIterator(),
                                 F->getBasicBlockList(),
                                 NewBlocks[0]->getIterator(),
                                 F->end());
 
   // Loop structure should be the following:

test/Transforms/LoopUnroll/2004-05-13-DontUnrollTooMuch.ll

-; RUN: opt < %s -loop-unroll -disable-output
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -disable-output
 
 define i32 @main() {
 entry:
   br label %no_exit
 no_exit:    ; preds = %no_exit, %entry
   %indvar = phi i32 [ 0, %entry ], [ %indvar.next, %no_exit ]    ; <i32> [#uses=1]
   %indvar.next = add i32 %indvar, 1   ; <i32> [#uses=2]
   %exitcond = icmp ne i32 %indvar.next, -2147483648    ; <i1> [#uses=1]
   br i1 %exitcond, label %no_exit, label %loopexit
 loopexit:   ; preds = %no_exit
   ret i32 0
 }
 

test/Transforms/LoopUnroll/2005-03-06-BadLoopInfoUpdate.ll

-; RUN: opt < %s -loop-unroll -loop-simplify -disable-output
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -loop-simplify -disable-output
 
 define void @print_board() {
 entry:
   br label %no_exit.1
 no_exit.1:    ; preds = %cond_false.2, %entry
   br label %no_exit.2
 no_exit.2:    ; preds = %no_exit.2, %no_exit.1
   %indvar1 = phi i32 [ 0, %no_exit.1 ], [ %indvar.next2, %no_exit.2 ]    ; <i32> [#uses=1]

test/Transforms/LoopUnroll/2006-08-24-MultiBlockLoop.ll

-; RUN: opt < %s -loop-unroll -S | grep bb72.2
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -S | grep bb72.2
 
 define void @vorbis_encode_noisebias_setup() {
 entry:
   br label %cond_true.outer
 cond_true.outer:    ; preds = %bb72, %entry
   %indvar1.ph = phi i32 [ 0, %entry ], [ %indvar.next2, %bb72 ]    ; <i32> [#uses=1]
   br label %bb72
 bb72:   ; preds = %cond_true.outer
   %indvar.next2 = add i32 %indvar1.ph, 1    ; <i32> [#uses=2]
   %exitcond3 = icmp eq i32 %indvar.next2, 3    ; <i1> [#uses=1]
   br i1 %exitcond3, label %cond_true138, label %cond_true.outer
 cond_true138:   ; preds = %bb72
   ret void
 }
 

test/Transforms/LoopUnroll/2007-04-16-PhiUpdate.ll

 ; PR 1334
-; RUN: opt < %s -loop-unroll -disable-output
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -disable-output
 
 define void @sal__math_float_manipulator_7__math__joint_array_dcv_ops__Omultiply__3([6 x float]* %agg.result) {
 entry:
   %tmp282911 = zext i8 0 to i32   ; <i32> [#uses=1]
   br label %cond_next
 cond_next:    ; preds = %cond_next, %entry
   %indvar = phi i8 [ 0, %entry ], [ %indvar.next, %cond_next ]    ; <i8> [#uses=1]
   %indvar.next = add i8 %indvar, 1    ; <i8> [#uses=2]
   %exitcond = icmp eq i8 %indvar.next, 7    ; <i1> [#uses=1]
   br i1 %exitcond, label %bb27, label %cond_next
 bb27:   ; preds = %cond_next
   %tmp282911.lcssa = phi i32 [ %tmp282911, %cond_next ]    ; <i32> [#uses=0]
   ret void
 }
 

test/Transforms/LoopUnroll/2007-05-05-UnrollMiscomp.ll

-; RUN: opt < %s -loop-unroll -S | not grep undef
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -S | not grep undef
 ; PR1385
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64"
 target triple = "i686-apple-darwin8"
         %struct.__mpz_struct = type { i32, i32, i32* }
 
 
 define void @Foo(%struct.__mpz_struct* %base) {

test/Transforms/LoopUnroll/2007-05-09-UnknownTripCount.ll

-; RUN: opt < %s -loop-unroll -unroll-count=3 -S | grep bb72.2
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -unroll-count=3 -S | grep bb72.2
 
 define void @foo(i32 %trips) {
 entry:
   br label %cond_true.outer
 
 cond_true.outer:
   %indvar1.ph = phi i32 [ 0, %entry ], [ %indvar.next2, %bb72 ]
   br label %bb72

test/Transforms/LoopUnroll/2007-11-05-Crash.ll

-; RUN: opt < %s -disable-output -loop-unroll
+; RUN: opt < %s -disable-output -loop-unroll -unroll-verify-domtree
 ; PR1770
 ; PR1947
 
   %struct.cl_engine = type { i32, i16, i32, i8**, i8**, i8*, i8*, i8*, i8*, i8*, i8*, i8* }
   %struct.cl_limits = type { i32, i32, i32, i32, i16, i64 }
   %struct.cli_ac_alt = type { i8, i8*, i16, i16, %struct.cli_ac_alt* }
   %struct.cli_ac_node = type { i8, i8, %struct.cli_ac_patt*, %struct.cli_ac_node**, %struct.cli_ac_node* }
   %struct.cli_ac_patt = type { i16*, i16*, i16, i16, i8, i32, i32, i8*, i8*, i32, i16, i16, i16, i16, %struct.cli_ac_alt**, i8, i16, %struct.cli_ac_patt*, %struct.cli_ac_patt* }

test/Transforms/LoopUnroll/2011-08-08-PhiUpdate.ll

-; RUN: opt < %s -loop-unroll -S -unroll-count=4 | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -S -unroll-count=4 | FileCheck %s
 ; Test phi update after partial unroll.
 
 declare i1 @check() nounwind
 
 ; CHECK: @test
 ; CHECK: if.else:
 ; CHECK: if.then.loopexit
 ; CHECK: %sub5.lcssa = phi i32 [ %sub{{.*}}, %if.else{{.*}} ], [ %sub{{.*}}, %if.else{{.*}} ], [ %sub{{.*}}, %if.else{{.*}} ], [ %sub{{.*}}, %if.else{{.*}} ]

test/Transforms/LoopUnroll/2011-08-09-IVSimplify.ll

-; RUN: opt -S < %s -loop-unroll -unroll-count=4 | FileCheck %s
+; RUN: opt -S < %s -loop-unroll -unroll-verify-domtree -unroll-count=4 | FileCheck %s
 ;
 ; Test induction variable simplify after loop unrolling. It should
 ; expose nice opportunities for GVN.
 ;
 ; CHECK-NOT: while.body also ensures that loop unrolling (with SCEV)
 ; removes unrolled loop exits given that 128 is a multiple of 4.
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"

test/Transforms/LoopUnroll/2011-08-09-PhiUpdate.ll

-; RUN: opt -S < %s -instcombine -inline -jump-threading -loop-unroll -unroll-count=4 | FileCheck %s
+; RUN: opt -S < %s -instcombine -inline -jump-threading -loop-unroll -unroll-verify-domtree -unroll-count=4 | FileCheck %s
 ;
 ; This is a test case that required a number of setup passes because
 ; it depends on block order.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-macosx10.6.8"
 
 declare i1 @check() nounwind

test/Transforms/LoopUnroll/2011-10-01-NoopTrunc.ll

-; RUN: opt < %s -S -loop-unroll -unroll-threshold=150 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-threshold=150 | FileCheck %s
 ;
 ; Verify that trunc i64 to i32 is considered free by loop unrolling
 ; heuristics when i32 is a native type.
 ; This should result in full unrolling this loop with size=7, TC=19.
 ; If the trunc were not free we would have 8*19=152 > 150.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 

test/Transforms/LoopUnroll/2012-04-09-unroll-indirectbr.ll

-; RUN: opt < %s -S -loop-unroll -simplifycfg | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -simplifycfg | FileCheck %s
 ; PR12513: Loop unrolling breaks with indirect branches.
 ; If loop unrolling attempts to transform this loop, it replaces the
 ; indirectbr successors. SimplifyCFG then considers them to be unreachable.
 declare void @subtract() nounwind uwtable
 
 ; CHECK-NOT: unreachable
 define i32 @main(i32 %argc, i8** nocapture %argv) nounwind uwtable {
 entry:

test/Transforms/LoopUnroll/AArch64/full-unroll-trip-count-upper-bound.ll

-; RUN: opt -loop-unroll -S -mtriple aarch64 -mcpu=cortex-a57 %s | FileCheck %s -check-prefix=UNROLL
-; RUN: opt -loop-unroll -unroll-max-upperbound=0 -S -mtriple aarch64 -mcpu=cortex-a57 %s | FileCheck %s -check-prefix=NOUNROLL
+; RUN: opt -loop-unroll -unroll-verify-domtree -S -mtriple aarch64 -mcpu=cortex-a57 %s | FileCheck %s -check-prefix=UNROLL
+; RUN: opt -loop-unroll -unroll-verify-domtree -unroll-max-upperbound=0 -S -mtriple aarch64 -mcpu=cortex-a57 %s | FileCheck %s -check-prefix=NOUNROLL
 
 ; This IR comes from this C code:
 ;
 ;   for (int i = 0; i < 4; i++) {
 ;     if (src[i] == 1) {
 ;       *dst = i;
 ;       break;
 ;     }

test/Transforms/LoopUnroll/AArch64/partial.ll

-; RUN: opt < %s -S -loop-unroll -mtriple aarch64 -mcpu=cortex-a57 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -mtriple aarch64 -mcpu=cortex-a57 | FileCheck %s
 
 ; Partial unroll 8 times for this loop.
 define void @unroll1() nounwind {
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %inc, %loop ]

test/Transforms/LoopUnroll/AArch64/runtime-loop.ll

-; RUN: opt < %s -S -loop-unroll -mtriple aarch64 -mcpu=cortex-a57 -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
-; RUN: opt < %s -S -loop-unroll -mtriple aarch64 -mcpu=cortex-a57 -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -mtriple aarch64 -mcpu=cortex-a57 -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -mtriple aarch64 -mcpu=cortex-a57 -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
 
 ; Tests for unrolling loops with run-time trip counts
 
 ; EPILOG:  %xtraiter = and i32 %n
 ; EPILOG:  for.body:
 ; EPILOG:  %lcmp.mod = icmp ne i32 %xtraiter, 0
 ; EPILOG:  br i1 %lcmp.mod, label %for.body.epil.preheader, label %for.end.loopexit
 ; EPILOG:  for.body.epil:

test/Transforms/LoopUnroll/AMDGPU/unroll-barrier.ll

-; RUN: opt -mtriple=amdgcn-unknown-amdhsa -mcpu=hawaii -loop-unroll -S < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-unknown-amdhsa -mcpu=hawaii -loop-unroll -unroll-verify-domtree -S < %s | FileCheck %s
 
 ; CHECK-LABEL: @test_unroll_convergent_barrier(
 ; CHECK: call void @llvm.amdgcn.s.barrier()
 ; CHECK: call void @llvm.amdgcn.s.barrier()
 ; CHECK: call void @llvm.amdgcn.s.barrier()
 ; CHECK: call void @llvm.amdgcn.s.barrier()
 ; CHECK-NOT: br
 define void @test_unroll_convergent_barrier(i32 addrspace(1)* noalias nocapture %out, i32 addrspace(1)* noalias nocapture %in) #0 {

test/Transforms/LoopUnroll/PowerPC/a2-high-cost-trip-count-computation.ll

-; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=a2 -loop-unroll | FileCheck %s
+; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=a2 -loop-unroll -unroll-verify-domtree | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 ;; Check that we do emit expensive instructions to compute trip
 ;; counts when unrolling loops on the a2 (because we unroll a lot).
 
 define i32 @test(i64 %v12, i8* %array, i64* %loc) {
 ; CHECK-LABEL: @test(

test/Transforms/LoopUnroll/PowerPC/a2-unrolling.ll

-; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=a2 -loop-unroll -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
-; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=a2 -loop-unroll -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
+; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=a2 -loop-unroll -unroll-verify-domtree -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
+; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=a2 -loop-unroll -unroll-verify-domtree -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
 
 define i32 @test(i32* nocapture %a, i32 %n) nounwind uwtable readonly {
 entry:
   %cmp1 = icmp eq i32 %n, 0
   br i1 %cmp1, label %for.end, label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]

test/Transforms/LoopUnroll/PowerPC/p7-unrolling.ll

-; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 -loop-unroll | FileCheck %s
+; RUN: opt < %s -S -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 -loop-unroll -unroll-verify-domtree | FileCheck %s
 define void @unroll_default() nounwind {
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %inc, %loop ]
   %inc = add i32 %iv, 1
   %exitcnd = icmp uge i32 %inc, 1024

test/Transforms/LoopUnroll/X86/mmx.ll

-; RUN: opt < %s -S -loop-unroll | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define x86_mmx @f() #0 {
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry

test/Transforms/LoopUnroll/X86/partial.ll

-; RUN: opt < %s -S -loop-unroll -mcpu=nehalem | FileCheck %s
-; RUN: opt < %s -S -loop-unroll -mcpu=core -unroll-runtime=0 | FileCheck -check-prefix=CHECK-NOUNRL %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -mcpu=nehalem | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -mcpu=core -unroll-runtime=0 | FileCheck -check-prefix=CHECK-NOUNRL %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo(i32* noalias nocapture readnone %ip, double %alpha, double* noalias nocapture %a, double* noalias nocapture readonly %b) #0 {
 entry:
   br label %vector.body
 
 vector.body:                                      ; preds = %vector.body, %entry

test/Transforms/LoopUnroll/basic.ll

-; RUN: opt < %s -loop-unroll -S | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -S | FileCheck %s
 
 
 ; This should not unroll since the address of the loop header is taken.
 
 ; CHECK-LABEL: @test1(
 ; CHECK: store i8* blockaddress(@test1, %l1), i8** %P
 ; CHECK: l1:
 ; CHECK-NEXT: phi i32

test/Transforms/LoopUnroll/convergent.ll

-; RUN: opt < %s -loop-unroll -unroll-runtime -unroll-allow-partial -S | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -unroll-runtime -unroll-allow-partial -S | FileCheck %s
 
 declare void @f() convergent
 
 ; Although this loop contains a convergent instruction, it should be
 ; fully unrolled.
 ;
 ; CHECK-LABEL: @full_unroll(
 define i32 @full_unroll() {

test/Transforms/LoopUnroll/ephemeral.ll

-; RUN: opt < %s -S -loop-unroll -unroll-threshold=50 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-threshold=50 | FileCheck %s
 
 ; Make sure this loop is completely unrolled...
 ; CHECK-LABEL: @test1
 ; CHECK: for.body:
 ; CHECK-NOT: for.end:
 
 define i32 @test1(i32* nocapture %a) nounwind uwtable readonly {
 entry:

test/Transforms/LoopUnroll/full-unroll-bad-cost.ll

-; RUN: opt -S -loop-unroll < %s | FileCheck %s
+; RUN: opt -S -loop-unroll -unroll-verify-domtree < %s | FileCheck %s
 
 ; LLVM should not try to fully unroll this loop.
 
 declare void @f()
 declare void @g()
 declare void @h()
 
 define void @trivial_loop() {

test/Transforms/LoopUnroll/full-unroll-crashers.ll

 ; Check that we don't crash on corner cases.
-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=1 -unroll-percent-dynamic-cost-saved-threshold=20 -o /dev/null
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=1 -unroll-percent-dynamic-cost-saved-threshold=20 -o /dev/null
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @known_constant = internal unnamed_addr constant [10 x i32] [i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1], align 16
 
 define void @foo1() {
 entry:
   br label %for.body
 

test/Transforms/LoopUnroll/full-unroll-heuristics-2.ll

-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=70 -unroll-dynamic-cost-savings-discount=90 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=70 -unroll-dynamic-cost-savings-discount=90 | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @unknown_global = internal unnamed_addr global [9 x i32] [i32 0, i32 -1, i32 0, i32 -1, i32 5, i32 -1, i32 0, i32 -1, i32 0], align 16
 @weak_constant = weak unnamed_addr constant [9 x i32] [i32 0, i32 -1, i32 0, i32 -1, i32 5, i32 -1, i32 0, i32 -1, i32 0], align 16
 
 ; Though @unknown_global is initialized with constant values, we can't consider
 ; it as a constant, so we shouldn't unroll the loop.
 ; CHECK-LABEL: @foo

test/Transforms/LoopUnroll/full-unroll-heuristics-cmp.ll

-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=40 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=40 | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @known_constant = internal unnamed_addr constant [10 x i32] [i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1], align 16
 
 ; If we can figure out result of comparison on each iteration, we can resolve
 ; the depending branch. That means, that the unrolled version of the loop would
 ; have less code, because we don't need not-taken basic blocks there.
 ; This test checks that this is taken into consideration.

test/Transforms/LoopUnroll/full-unroll-heuristics-dce.ll

-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=60 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=60 | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @known_constant = internal unnamed_addr constant [10 x i32] [i32 0, i32 0, i32 0, i32 0, i32 1, i32 0, i32 0, i32 0, i32 0, i32 0], align 16
 
 ; If a load becomes a constant after loop unrolling, we sometimes can simplify
 ; CFG. This test verifies that we handle such cases.
 ; After one operand in an instruction is constant-folded and the
 ; instruction is simplified, the other operand might become dead.

test/Transforms/LoopUnroll/full-unroll-heuristics-geps.ll

-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=60 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=60 | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; When examining gep-instructions we shouldn't consider them simplified if the
 ; corresponding memory access isn't simplified. Doing the opposite might bias
 ; our estimate, so that we might decide to unroll even a simple memcpy loop.
 ;
 ; Thus, the following loop shouldn't be unrolled:
 ; CHECK-LABEL: @not_simplified_geps

test/Transforms/LoopUnroll/full-unroll-heuristics-phi-prop.ll

-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=50 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=100 -unroll-dynamic-cost-savings-discount=1000 -unroll-threshold=10 -unroll-percent-dynamic-cost-saved-threshold=50 | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 define i64 @propagate_loop_phis() {
 ; CHECK-LABEL: @propagate_loop_phis(
 ; CHECK-NOT: br i1
 ; CHECK: ret i64 3
 entry:
   br label %loop

test/Transforms/LoopUnroll/full-unroll-heuristics.ll

 ;  * If a loop size is between these two tresholds, we only do complete unroll
 ;    it if estimated number of potentially optimized instructions is high (we
 ;    specify the minimal percent of such instructions).
 
 ; In this particular test-case, complete unrolling will allow later
 ; optimizations to remove ~55% of the instructions, the loop body size is 9,
 ; and unrolled size is 65.
 
-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=20 -unroll-dynamic-cost-savings-discount=0 | FileCheck %s -check-prefix=TEST1
-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=20 -unroll-dynamic-cost-savings-discount=90 | FileCheck %s -check-prefix=TEST2
-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=80 -unroll-dynamic-cost-savings-discount=90 | FileCheck %s -check-prefix=TEST3
-; RUN: opt < %s -S -loop-unroll -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=100 -unroll-percent-dynamic-cost-saved-threshold=80 -unroll-dynamic-cost-savings-discount=0 | FileCheck %s -check-prefix=TEST4
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=20 -unroll-dynamic-cost-savings-discount=0 | FileCheck %s -check-prefix=TEST1
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=20 -unroll-dynamic-cost-savings-discount=90 | FileCheck %s -check-prefix=TEST2
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=10  -unroll-percent-dynamic-cost-saved-threshold=80 -unroll-dynamic-cost-savings-discount=90 | FileCheck %s -check-prefix=TEST3
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=1000 -unroll-threshold=100 -unroll-percent-dynamic-cost-saved-threshold=80 -unroll-dynamic-cost-savings-discount=0 | FileCheck %s -check-prefix=TEST4
 
 ; If the absolute threshold is too low, or if we can't optimize away requested
 ; percent of instructions, we shouldn't unroll:
 ; TEST1: %array_const_idx = getelementptr inbounds [9 x i32], [9 x i32]* @known_constant, i64 0, i64 %iv
 ; TEST3: %array_const_idx = getelementptr inbounds [9 x i32], [9 x i32]* @known_constant, i64 0, i64 %iv
 
 ; Otherwise, we should:
 ; TEST2-NOT: %array_const_idx = getelementptr inbounds [9 x i32], [9 x i32]* @known_constant, i64 0, i64 %iv
 
 ; Also, we should unroll if the 'unroll-threshold' is big enough:
 ; TEST4-NOT: %array_const_idx = getelementptr inbounds [9 x i32], [9 x i32]* @known_constant, i64 0, i64 %iv
 
 ; And check that we don't crash when we're not allowed to do any analysis.
-; RUN: opt < %s -loop-unroll -unroll-max-iteration-count-to-analyze=0 -disable-output
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -unroll-max-iteration-count-to-analyze=0 -disable-output
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @known_constant = internal unnamed_addr constant [9 x i32] [i32 0, i32 -1, i32 0, i32 -1, i32 5, i32 -1, i32 0, i32 -1, i32 0], align 16
 
 define i32 @foo(i32* noalias nocapture readonly %src) {
 entry:
   br label %loop
 

test/Transforms/LoopUnroll/full-unroll-keep-first-exit.ll

-; RUN: opt -S -loop-unroll < %s | FileCheck %s
+; RUN: opt -S -loop-unroll -unroll-verify-domtree < %s | FileCheck %s
 
 ; Unroll twice, with first loop exit kept
 ; CHECK-LABEL: @s32_max1
 ; CHECK: do.body:
 ; CHECK:  store
 ; CHECK:  br i1 %cmp, label %do.body.1, label %do.end
 ; CHECK: do.end:
 ; CHECK:  ret void

test/Transforms/LoopUnroll/high-cost-trip-count-computation.ll

-; RUN: opt -S -unroll-runtime -loop-unroll < %s | FileCheck %s
+; RUN: opt -S -unroll-runtime -loop-unroll -unroll-verify-domtree < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 ;; Check that we don't emit expensive instructions to compute trip
 ;; counts when unrolling loops.
 
 define i32 @test(i64 %v12, i8* %array, i64* %loc) {
 ; CHECK-LABEL: @test(

test/Transforms/LoopUnroll/ignore-annotation-intrinsic-cost.ll

 ; REQUIRES: asserts
-; RUN: opt < %s -disable-output -stats -loop-unroll -info-output-file - | FileCheck %s --check-prefix=STATS
+; RUN: opt < %s -disable-output -stats -loop-unroll -unroll-verify-domtree -info-output-file - | FileCheck %s --check-prefix=STATS
 ; STATS: 1 loop-unroll - Number of loops unrolled (completely or otherwise)
 ; Test that llvm.annotation intrinsic do not count against the loop body size
 ; and prevent unrolling.
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
 
 @B = common global i32 0, align 4
 
 define void @foo(i32* noalias %A, i32 %B, i32 %C) {

test/Transforms/LoopUnroll/loop-remarks-with-hotness.ll

-; RUN: opt < %s -S -loop-unroll -pass-remarks=loop-unroll -pass-remarks-with-hotness -unroll-count=16 2>&1 | FileCheck -check-prefix=COMPLETE-UNROLL %s
-; RUN: opt < %s -S -loop-unroll -pass-remarks=loop-unroll -pass-remarks-with-hotness -unroll-count=4 2>&1 | FileCheck -check-prefix=PARTIAL-UNROLL %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -pass-remarks=loop-unroll -pass-remarks-with-hotness -unroll-count=16 2>&1 | FileCheck -check-prefix=COMPLETE-UNROLL %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -pass-remarks=loop-unroll -pass-remarks-with-hotness -unroll-count=4 2>&1 | FileCheck -check-prefix=PARTIAL-UNROLL %s
 
 ; COMPLETE-UNROLL: remark: {{.*}}: completely unrolled loop with 16 iterations (hotness: 300)
 ; PARTIAL-UNROLL: remark: {{.*}}: unrolled loop by a factor of 4 {{.*}} (hotness: 300)
 
 define i32 @sum() !prof !0 {
 entry:
   br label %for.body
 

test/Transforms/LoopUnroll/loop-remarks.ll

-; RUN: opt < %s -S -loop-unroll -pass-remarks=loop-unroll -unroll-count=16 2>&1 | FileCheck -check-prefix=COMPLETE-UNROLL %s
-; RUN: opt < %s -S -loop-unroll -pass-remarks=loop-unroll -unroll-count=4 2>&1 | FileCheck -check-prefix=PARTIAL-UNROLL %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -pass-remarks=loop-unroll -unroll-count=16 2>&1 | FileCheck -check-prefix=COMPLETE-UNROLL %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -pass-remarks=loop-unroll -unroll-count=4 2>&1 | FileCheck -check-prefix=PARTIAL-UNROLL %s
 
 ; COMPLETE-UNROLL: remark: {{.*}}: completely unrolled loop with 16 iterations
 ; PARTIAL-UNROLL: remark: {{.*}}: unrolled loop by a factor of 4
 
 define i32 @sum() {
 entry:
   br label %for.body
 

test/Transforms/LoopUnroll/partial-unroll-const-bounds.ll

-; RUN: opt < %s -S -unroll-threshold=20 -loop-unroll -unroll-allow-partial -unroll-runtime -unroll-allow-remainder -unroll-dynamic-cost-savings-discount=0 | FileCheck %s
+; RUN: opt < %s -S -unroll-threshold=20 -loop-unroll -unroll-verify-domtree -unroll-allow-partial -unroll-runtime -unroll-allow-remainder -unroll-dynamic-cost-savings-discount=0 | FileCheck %s
 
 ; The Loop TripCount is 9. However unroll factors 3 or 9 exceed given threshold.
 ; The test checks that we choose a smaller, power-of-two, unroll count and do not give up on unrolling.
 
 ; CHECK: for.body:
 ; CHECK: store
 ; CHECK: for.body.1:
 ; CHECK: store

test/Transforms/LoopUnroll/peel-loop-pgo.ll

-; RUN: opt < %s -S -debug-only=loop-unroll -loop-unroll -unroll-allow-peeling 2>&1 | FileCheck %s
+; RUN: opt < %s -S -debug-only=loop-unroll -loop-unroll -unroll-verify-domtree -unroll-allow-peeling 2>&1 | FileCheck %s
 ; REQUIRES: asserts
 
 ; Make sure we use the profile information correctly to peel-off 3 iterations
 ; from the loop, and update the branch weights for the peeled loop properly.
 ; CHECK: PEELING loop %for.body with iteration count 3!
 ; CHECK-LABEL: @basic
 ; CHECK: br i1 %{{.*}}, label %[[NEXT0:.*]], label %for.cond.for.end_crit_edge, !prof !1
 ; CHECK: [[NEXT0]]:

test/Transforms/LoopUnroll/peel-loop.ll

-; RUN: opt < %s -S -loop-unroll -unroll-force-peel-count=3 -simplifycfg -instcombine | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-force-peel-count=3 -simplifycfg -instcombine | FileCheck %s
 
 ; Basic loop peeling - check that we can peel-off the first 3 loop iterations
 ; when explicitly requested.
 ; CHECK-LABEL: @basic
 ; CHECK: %[[CMP0:.*]] = icmp sgt i32 %k, 0
 ; CHECK: br i1 %[[CMP0]], label %[[NEXT0:.*]], label %for.end
 ; CHECK: [[NEXT0]]:
 ; CHECK: store i32 0, i32* %p, align 4

test/Transforms/LoopUnroll/pr10813.ll

-; RUN: opt < %s -loop-unroll -disable-output
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -disable-output
 
 define void @"f_fu___REFUf[]REFUf[]Uf"() nounwind {
 allocas:
   br i1 undef, label %cif_mask_all, label %cif_mixed_test_all
 
 cif_mask_all:                                     ; preds = %allocas
   unreachable
 

test/Transforms/LoopUnroll/pr11361.ll

-; RUN: opt -loop-unroll -disable-output < %s
+; RUN: opt -loop-unroll -unroll-verify-domtree -disable-output < %s
 ; PR11361
 
 ; This tests for an iterator invalidation issue.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @func_1() nounwind uwtable {

test/Transforms/LoopUnroll/pr14167.ll

-; RUN: opt < %s -S -loop-unroll -unroll-runtime | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime | FileCheck %s
 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64"
 target triple = "powerpc64-bgq-linux"
 
 define void @test1() nounwind {
 ; Ensure that we don't crash when the trip count == -1.
 ; CHECK-LABEL: @test1(
 entry:
   br label %for.cond2.preheader

test/Transforms/LoopUnroll/pr18861.ll

-; RUN: opt < %s -loop-unroll -indvars -disable-output
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -indvars -disable-output
 
 @b = external global i32, align 4
 
 ; Test that LoopUnroll does not break LCSSA form.
 ;
 ; In this function we have a following CFG:
 ;            ( entry )
 ;                |

test/Transforms/LoopUnroll/pr27157.ll

-; RUN: opt -loop-unroll -debug-only=loop-unroll -disable-output < %s
+; RUN: opt -loop-unroll -unroll-verify-domtree -debug-only=loop-unroll -disable-output < %s
 ; REQUIRES: asserts
 ; Compile this test with debug flag on to verify domtree right after loop unrolling.
 target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"
 
 ; PR27157
 define void @foo() {
 entry:
   br label %loop_header

test/Transforms/LoopUnroll/pr28132.ll

-; RUN: opt -loop-unroll -S < %s | FileCheck %s
+; RUN: opt -loop-unroll -unroll-verify-domtree -S < %s | FileCheck %s
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc"
 
 declare void @fn1(i8*)
 
 declare i1 @fn2(i8*, i8*)
 
 define void @fn4() personality i32 (...)* @__CxxFrameHandler3 {

test/Transforms/LoopUnroll/rebuild_lcssa.ll

-; RUN: opt < %s -loop-unroll -S | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; This test shows how unrolling an inner loop could break LCSSA for an outer
 ; loop, and there is no cheap way to recover it.
 ;
 ; In this case the inner loop, L3, is being unrolled. It only runs one
 ; iteration, so unrolling basically means replacing
 ;   br i1 true, label %exit, label %L3_header

test/Transforms/LoopUnroll/runtime-loop.ll

-; RUN: opt < %s -S -loop-unroll -unroll-runtime=true -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
-; RUN: opt < %s -S -loop-unroll -unroll-runtime=true -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime=true -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime=true -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 ; Tests for unrolling loops with run-time trip counts
 
 ; EPILOG: %xtraiter = and i32 %n
 ; EPILOG:  %lcmp.mod = icmp ne i32 %xtraiter, 0
 ; EPILOG:  br i1 %lcmp.mod, label %for.body.epil.preheader, label %for.end.loopexit

test/Transforms/LoopUnroll/runtime-loop1.ll

-; RUN: opt < %s -S -loop-unroll -unroll-runtime -unroll-count=2 -unroll-runtime-epilog=true | FileCheck %s -check-prefix=EPILOG
-; RUN: opt < %s -S -loop-unroll -unroll-runtime -unroll-count=2 -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime -unroll-count=2 -unroll-runtime-epilog=true | FileCheck %s -check-prefix=EPILOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime -unroll-count=2 -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
 
 ; This tests that setting the unroll count works
 
 
 ; EPILOG: for.body.preheader:
 ; EPILOG:   br i1 %1, label %for.end.loopexit.unr-lcssa, label %for.body.preheader.new, !dbg [[PH_LOC:![0-9]+]]
 ; EPILOG: for.body:
 ; EPILOG:   br i1 %niter.ncmp.1, label %for.end.loopexit.unr-lcssa.loopexit, label %for.body, !dbg [[BODY_LOC:![0-9]+]]

test/Transforms/LoopUnroll/runtime-loop2.ll

-; RUN: opt < %s -S -loop-unroll -unroll-threshold=25 -unroll-runtime -unroll-runtime-epilog=true  -unroll-count=8 | FileCheck %s  -check-prefix=EPILOG
-; RUN: opt < %s -S -loop-unroll -unroll-threshold=25 -unroll-runtime -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-threshold=25 -unroll-runtime -unroll-runtime-epilog=true  -unroll-count=8 | FileCheck %s  -check-prefix=EPILOG
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-threshold=25 -unroll-runtime -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
 
 ; Choose a smaller, power-of-two, unroll count if the loop is too large.
 ; This test makes sure we're not unrolling 'odd' counts
 
 ; EPILOG: for.body:
 ; EPILOG: br i1 %niter.ncmp.3, label %for.end.loopexit.unr-lcssa.loopexit{{.*}}, label %for.body
 ; EPILOG-NOT: br i1 %niter.ncmp.4, label %for.end.loopexit.unr-lcssa.loopexit{{.*}}, label %for.body
 ; EPILOG: for.body.epil:

test/Transforms/LoopUnroll/runtime-loop3.ll

 ; REQUIRES: asserts
-; RUN: opt < %s -disable-output -stats -loop-unroll -unroll-runtime -unroll-threshold=400 -info-output-file - | FileCheck %s --check-prefix=STATS
+; RUN: opt < %s -disable-output -stats -loop-unroll -unroll-verify-domtree -unroll-runtime -unroll-threshold=400 -info-output-file - | FileCheck %s --check-prefix=STATS
 
 ; Test that nested loops can be unrolled.  We need to increase threshold to do it
 
 ; STATS: 2 loop-unroll - Number of loops unrolled (completely or otherwise)
 
 define i32 @nested(i32* nocapture %a, i32 %n, i32 %m) nounwind uwtable readonly {
 entry:
   %cmp11 = icmp sgt i32 %n, 0

test/Transforms/LoopUnroll/runtime-loop5.ll

-; RUN: opt < %s -S -loop-unroll -unroll-runtime=true -unroll-count=16 | FileCheck --check-prefix=UNROLL-16 %s
-; RUN: opt < %s -S -loop-unroll -unroll-runtime=true -unroll-count=4 | FileCheck --check-prefix=UNROLL-4 %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime=true -unroll-count=16 | FileCheck --check-prefix=UNROLL-16 %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime=true -unroll-count=4 | FileCheck --check-prefix=UNROLL-4 %s
 
 ; Given that the trip-count of this loop is a 3-bit value, we cannot
 ; safely unroll it with a count of anything more than 8.
 
 define i3 @test(i3* %a, i3 %n) {
 ; UNROLL-16-LABEL: @test(
 ; UNROLL-4-LABEL: @test(
 entry:

test/Transforms/LoopUnroll/scevunroll.ll

-; RUN: opt < %s -S -indvars -loop-unroll -verify-loop-info | FileCheck %s
+; RUN: opt < %s -S -indvars -loop-unroll -unroll-verify-domtree -verify-loop-info | FileCheck %s
 ;
 ; Unit tests for loop unrolling using ScalarEvolution to compute trip counts.
 ;
 ; Indvars is run first to generate an "old" SCEV result. Some unit
 ; tests may check that SCEV is properly invalidated between passes.
 
 ; Completely unroll loops without a canonical IV.
 ;

test/Transforms/LoopUnroll/shifted-tripcount.ll

-; RUN: opt < %s -loop-unroll -unroll-count=2 -S | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -unroll-count=2 -S | FileCheck %s
 
 ; LoopUnroll should unroll this loop into one big basic block.
 
 ; CHECK: for.body:
 ; CHECK: %i.013 = phi i64 [ 0, %entry ], [ %tmp16.1, %for.body ]
 ; CHECK: br i1 %exitcond.1, label %for.end, label %for.body
 
 define void @foo(double* nocapture %p, i64 %n) nounwind {

test/Transforms/LoopUnroll/tripcount-overflow.ll

-; RUN: opt < %s -S -unroll-runtime -unroll-count=2 -loop-unroll -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
-; RUN: opt < %s -S -unroll-runtime -unroll-count=2 -loop-unroll -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
+; RUN: opt < %s -S -unroll-runtime -unroll-count=2 -loop-unroll -unroll-verify-domtree -unroll-runtime-epilog=true  | FileCheck %s -check-prefix=EPILOG
+; RUN: opt < %s -S -unroll-runtime -unroll-count=2 -loop-unroll -unroll-verify-domtree -unroll-runtime-epilog=false | FileCheck %s -check-prefix=PROLOG
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; This test case documents how runtime loop unrolling handles the case
 ; when the backedge-count is -1.
 
 ; If %N, the backedge-taken count, is -1 then %0 unsigned-overflows
 ; and is 0.  %xtraiter too is 0, signifying that the total trip-count
 ; is divisible by 2.  The prologue then branches to the unrolled loop

test/Transforms/LoopUnroll/unloop.ll

-; RUN: opt < %s -S -loop-unroll -verify-loop-info | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -verify-loop-info | FileCheck %s
 ; RUN: opt < %s -S -passes='function(require<scalar-evolution>,require<targetir>,require<opt-remark-emit>,loop(unroll),verify<loops>)' | FileCheck %s
 ;
 ; Unit tests for LoopInfo::markAsRemoved.
 
 declare i1 @check() nounwind
 
 ; Ensure that tail->inner is removed and rely on verify-loopinfo to
 ; check soundness.

test/Transforms/LoopUnroll/unroll-cleanuppad.ll

-; RUN: opt -S -loop-unroll %s | FileCheck %s
+; RUN: opt -S -loop-unroll -unroll-verify-domtree %s | FileCheck %s
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc18.0.0"
 
 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.inc

test/Transforms/LoopUnroll/unroll-count.ll

-; RUN: opt < %s -S -loop-unroll -unroll-count=2 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-count=2 | FileCheck %s
 ; Checks that "llvm.loop.unroll.disable" is set when
 ; unroll with count set by user has been applied.
 ;
 ; CHECK-LABEL: @foo(
 ; CHECK: llvm.loop.unroll.disable
 
 define void @foo(i32* nocapture %a) {
 entry:

test/Transforms/LoopUnroll/unroll-heuristics-pgo.ll

-; RUN: opt < %s -S -loop-unroll -unroll-runtime -unroll-threshold=40 -unroll-dynamic-cost-savings-discount=0 | FileCheck %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-runtime -unroll-threshold=40 -unroll-dynamic-cost-savings-discount=0 | FileCheck %s
 
 @known_constant = internal unnamed_addr constant [9 x i32] [i32 0, i32 -1, i32 0, i32 -1, i32 5, i32 -1, i32 0, i32 -1, i32 0], align 16
 
 ; CHECK-LABEL: @bar_prof
 ; CHECK: loop.prol:
 ; CHECK: loop:
 ; CHECK: %mul = mul
 ; CHECK: %mul.1 = mul

test/Transforms/LoopUnroll/unroll-opt-attribute.ll

-; RUN: opt < %s -S -loop-unroll -unroll-count=4 | FileCheck -check-prefix=CHECK_COUNT4 %s
-; RUN: opt < %s -S -loop-unroll | FileCheck -check-prefix=CHECK_NOCOUNT %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree -unroll-count=4 | FileCheck -check-prefix=CHECK_COUNT4 %s
+; RUN: opt < %s -S -loop-unroll -unroll-verify-domtree | FileCheck -check-prefix=CHECK_NOCOUNT %s
 
 
 ;///////////////////// TEST 1 //////////////////////////////
 
 ; This test shows that the loop is unrolled according to the specified
 ; unroll factor.
 
 define void @Test1() nounwind {

test/Transforms/LoopUnroll/unroll-pragmas-disabled.ll

-; RUN: opt < %s -loop-unroll -S | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -S | FileCheck %s
 ;
 ; Verify that the unrolling pass removes existing unroll count metadata
 ; and adds a disable unrolling node after unrolling is complete.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; #pragma clang loop  vectorize(enable) unroll_count(4) vectorize_width(8)

test/Transforms/LoopUnroll/unroll-pragmas.ll

-; RUN: opt < %s -loop-unroll -pragma-unroll-threshold=1024 -S | FileCheck %s
-; RUN: opt < %s -loop-unroll -loop-unroll -pragma-unroll-threshold=1024 -S | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -pragma-unroll-threshold=1024 -S | FileCheck %s
+; RUN: opt < %s -loop-unroll -unroll-verify-domtree -loop-unroll -pragma-unroll-threshold=1024 -S | FileCheck %s
 ;
 ; Run loop unrolling twice to verify that loop unrolling metadata is properly
 ; removed and further unrolling is disabled after the pass is run once.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; loop4 contains a small loop which should be completely unrolled by

test/Transforms/LoopUnroll/update-loop-info-in-subloops.ll

-; RUN: opt -S < %s -loop-unroll -block-freq | FileCheck %s
+; RUN: opt -S < %s -loop-unroll -unroll-verify-domtree -block-freq | FileCheck %s
 ; Crasher from PR20987.
 
 ; CHECK: define void @update_loop_info_in_subloops
 ; CHECK: entry:
 ; CHECK: L:
 ; CHECK: L.inner:
 ; CHECK: L.inner.latch:
 ; CHECK: L.latch: