diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index b539a78..0ccc085 100644
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -749,14 +749,17 @@ public:
     return DT->dominates(A, B);
   }
 
-  // dominates - Return true if A dominates B. This performs the
+  // dominatesUse - Return true if A dominates a use in B. This performs the
   // special checks necessary if A and B are in the same basic block.
-  bool dominates(const Instruction *A, const Instruction *B) const;
+  // Note that A doesn't dominate a use in A itself!
+  bool dominatesUse(const Instruction *A, const Instruction *B) const;
 
   /// properlyDominates - Use this instead of dominates() to determine whether a
   /// user of A can be hoisted above B.
   bool properlyDominates(const Instruction *A, const Instruction *B) const {
-    return A != B && dominates(A, B);
+    // Since A doesn't dominate a use in A, we don't need the extra A != B
+    // check.
+    return dominatesUse(A, B);
   }
 
   bool properlyDominates(const DomTreeNode *A, const DomTreeNode *B) const {
diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp
index 88a2c53..8652466 100644
--- a/lib/Analysis/InstructionSimplify.cpp
+++ b/lib/Analysis/InstructionSimplify.cpp
@@ -92,7 +92,7 @@ static bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) {
 
   // If we have a DominatorTree then do a precise test.
   if (DT)
-    return DT->dominates(I, P);
+    return DT->dominatesUse(I, P);
 
   // Otherwise, if the instruction is in the entry block, and is not an invoke,
   // then it obviously dominates all phi nodes.
diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp
index cfaf2da..02b43b6 100644
--- a/lib/Analysis/MemoryDependenceAnalysis.cpp
+++ b/lib/Analysis/MemoryDependenceAnalysis.cpp
@@ -350,14 +350,14 @@ namespace {
 
     bool shouldExplore(Use *U) {
       Instruction *I = cast<Instruction>(U->getUser());
-      if (BeforeHere != I && DT->dominates(BeforeHere, I))
+      if (BeforeHere != I && DT->dominatesUse(BeforeHere, I))
         return false;
       return true;
     }
 
     bool captured(Use *U) {
       Instruction *I = cast<Instruction>(U->getUser());
-      if (BeforeHere != I && DT->dominates(BeforeHere, I))
+      if (BeforeHere != I && DT->dominatesUse(BeforeHere, I))
         return false;
       Captured = true;
       return true;
diff --git a/lib/Analysis/ScalarEvolutionExpander.cpp b/lib/Analysis/ScalarEvolutionExpander.cpp
index 852c7a0..2c9d1e9 100644
--- a/lib/Analysis/ScalarEvolutionExpander.cpp
+++ b/lib/Analysis/ScalarEvolutionExpander.cpp
@@ -33,11 +33,8 @@ Value *SCEVExpander::ReuseOrCreateCast(Value *V, Type *Ty,
                                        BasicBlock::iterator IP) {
   // All new or reused instructions must strictly dominate the Builder's
   // InsertPt to ensure that the expression's expansion dominates its uses.
-  // Assert that the requested insertion point works at least for new
-  // instructions.
-
-  // FIXME: disabled to make the bots happy.
-  //assert(SE.DT->dominates(IP, Builder.GetInsertPoint()));
+  // We assert that just before each return as that is easier than checking IP
+  // and the instert location.
 
   // Check to see if there is already a cast!
   for (Value::use_iterator UI = V->use_begin(), E = V->use_end();
@@ -57,9 +54,11 @@ Value *SCEVExpander::ReuseOrCreateCast(Value *V, Type *Ty,
             CI->replaceAllUsesWith(NewCI);
             CI->setOperand(0, UndefValue::get(V->getType()));
             rememberInstruction(NewCI);
+            assert(SE.DT->properlyDominates(NewCI, Builder.GetInsertPoint()));
             return NewCI;
           }
           rememberInstruction(CI);
+          assert(SE.DT->properlyDominates(CI, Builder.GetInsertPoint()));
           return CI;
         }
   }
@@ -67,6 +66,7 @@ Value *SCEVExpander::ReuseOrCreateCast(Value *V, Type *Ty,
   // Create a new cast.
   Instruction *I = CastInst::Create(Op, V, Ty, V->getName(), IP);
   rememberInstruction(I);
+  assert(SE.DT->properlyDominates(I, Builder.GetInsertPoint()));
   return I;
 }
 
@@ -857,7 +857,7 @@ bool SCEVExpander::isNormalAddRecExprPHI(PHINode *PN, Instruction *IncV,
     for (User::op_iterator OI = IncV->op_begin()+1,
            OE = IncV->op_end(); OI != OE; ++OI)
       if (Instruction *OInst = dyn_cast<Instruction>(OI))
-        if (!SE.DT->dominates(OInst, IVIncInsertPos))
+        if (!SE.DT->dominatesUse(OInst, IVIncInsertPos))
           return false;
   }
   // Advance to the next instruction.
@@ -1043,7 +1043,7 @@ SCEVExpander::getAddRecExprPHILiterally(const SCEVAddRecExpr *Normalized,
           continue;
         if (L == IVIncInsertLoop)
           do {
-            if (SE.DT->dominates(IncV, IVIncInsertPos))
+            if (SE.DT->dominatesUse(IncV, IVIncInsertPos))
               break;
             // Make sure the increment is where we want it. But don't move it
             // down past a potential existing post-inc user.
@@ -1201,8 +1201,8 @@ Value *SCEVExpander::expandAddRecExprLiterally(const SCEVAddRecExpr *S) {
     // expandCodeFor with an InsertPoint that is either outside the PostIncLoop
     // or dominated by IVIncInsertPos.
     if (isa<Instruction>(Result)
-        && !SE.DT->dominates(cast<Instruction>(Result),
-                             Builder.GetInsertPoint())) {
+        && !SE.DT->dominatesUse(cast<Instruction>(Result),
+                                Builder.GetInsertPoint())) {
       // The induction variable's postinc expansion does not dominate this use.
       // IVUsers tries to prevent this case, so it is rare. However, it can
       // happen when an IVUser outside the loop is not dominated by the latch
diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
index 5b95f5b..e4bb653 100644
--- a/lib/Transforms/Scalar/GVN.cpp
+++ b/lib/Transforms/Scalar/GVN.cpp
@@ -1494,7 +1494,7 @@ bool GVN::processNonLocalLoad(LoadInst *LI) {
         // "Hot" Instruction is in some loop (because it dominates its dep.
         // instruction).
         if (Instruction *I = dyn_cast<Instruction>(AV.getSimpleValue()))
-          if (DT->dominates(LI, I)) {
+          if (DT->dominatesUse(LI, I)) {
             isHot = true;
             break;
           }
diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp
index 917ec58..4a322a3 100644
--- a/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -221,7 +221,7 @@ static Instruction *getInsertPointForUses(Instruction *User, Value *Def,
   }
   assert(InsertPt && "Missing phi operand");
   assert((!isa<Instruction>(Def) ||
-          DT->dominates(cast<Instruction>(Def), InsertPt)) &&
+          DT->dominatesUse(cast<Instruction>(Def), InsertPt)) &&
          "def does not dominate all uses");
   return InsertPt;
 }
diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
index 6768860..525d4a7 100644
--- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp
+++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
@@ -4113,14 +4113,14 @@ LSRInstance::HoistInsertPosition(BasicBlock::iterator IP,
     for (SmallVectorImpl<Instruction *>::const_iterator I = Inputs.begin(),
          E = Inputs.end(); I != E; ++I) {
       Instruction *Inst = *I;
-      if (Inst == Tentative || !DT.dominates(Inst, Tentative)) {
+      if (Inst == Tentative || !DT.dominatesUse(Inst, Tentative)) {
         AllDominate = false;
         break;
       }
       // Attempt to find an insert position in the middle of the block,
       // instead of at the end, so that it can be used for other expansions.
       if (IDom == Inst->getParent() &&
-          (!BetterPos || DT.dominates(BetterPos, Inst)))
+          (!BetterPos || DT.dominatesUse(BetterPos, Inst)))
         BetterPos = llvm::next(BasicBlock::iterator(Inst));
     }
     if (!AllDominate)
diff --git a/lib/Transforms/Scalar/MemCpyOptimizer.cpp b/lib/Transforms/Scalar/MemCpyOptimizer.cpp
index a87cce3..bc9c631 100644
--- a/lib/Transforms/Scalar/MemCpyOptimizer.cpp
+++ b/lib/Transforms/Scalar/MemCpyOptimizer.cpp
@@ -654,7 +654,7 @@ bool MemCpyOpt::performCallSlotOptzn(Instruction *cpy,
   // that what would be the new parameter dominates the callsite.
   DominatorTree &DT = getAnalysis<DominatorTree>();
   if (Instruction *cpyDestInst = dyn_cast<Instruction>(cpyDest))
-    if (!DT.dominates(cpyDestInst, C))
+    if (!DT.dominatesUse(cpyDestInst, C))
       return false;
 
   // In addition to knowing that the call does not access src in some
diff --git a/lib/Transforms/Scalar/ObjCARC.cpp b/lib/Transforms/Scalar/ObjCARC.cpp
index dd3e758..2205bdd 100644
--- a/lib/Transforms/Scalar/ObjCARC.cpp
+++ b/lib/Transforms/Scalar/ObjCARC.cpp
@@ -3996,7 +3996,7 @@ bool ObjCARCContract::runOnFunction(Function &F) {
         unsigned OperandNo = UI.getOperandNo();
         ++UI; // Increment UI now, because we may unlink its element.
         if (Instruction *UserInst = dyn_cast<Instruction>(U.getUser()))
-          if (Inst != UserInst && DT->dominates(Inst, UserInst)) {
+          if (Inst != UserInst && DT->dominatesUse(Inst, UserInst)) {
             Changed = true;
             Instruction *Replacement = Inst;
             Type *UseTy = U.get()->getType();
diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp
index d052f24..89143b6 100644
--- a/lib/VMCore/Dominators.cpp
+++ b/lib/VMCore/Dominators.cpp
@@ -82,13 +82,19 @@ void DominatorTree::print(raw_ostream &OS, const Module *) const {
 
 // dominates - Return true if A dominates a use in B. This performs the
 // special checks necessary if A and B are in the same basic block.
-bool DominatorTree::dominates(const Instruction *A, const Instruction *B) const{
+// Note that A doesn't dominate a use in A itself!
+bool DominatorTree::dominatesUse(const Instruction *A,
+                                 const Instruction *B) const{
+  // An instruction doesn't dominate a use in itself.
+  if (A == B)
+    return false;
+
   const BasicBlock *BBA = A->getParent(), *BBB = B->getParent();
 
   // If A is an invoke instruction, its value is only available in this normal
   // successor block.
   if (const InvokeInst *II = dyn_cast<InvokeInst>(A))
-    BBA = II->getNormalDest();
+    return dominates(II->getNormalDest(), BBB);
 
   if (BBA != BBB) return dominates(BBA, BBB);
 
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 066c2e7..14ec9e3 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -1648,7 +1648,7 @@ void Verifier::visitInstruction(Instruction &I) {
         }
 
         // Definition must dominate use unless use is unreachable!
-        Assert2(InstsInThisBlock.count(Op) || DT->dominates(Op, &I) ||
+        Assert2(InstsInThisBlock.count(Op) || DT->dominatesUse(Op, &I) ||
                 !DT->isReachableFromEntry(BB),
                 "Instruction does not dominate all uses!", Op, &I);
       }
diff --git a/test/Transforms/LoopStrengthReduce/normal_successor.ll b/test/Transforms/LoopStrengthReduce/normal_successor.ll
new file mode 100644
index 0000000..078b542
--- /dev/null
+++ b/test/Transforms/LoopStrengthReduce/normal_successor.ll
@@ -0,0 +1,53 @@
+; RUN: opt < %s -loop-reduce
+
+define void @f(i32* %foo) {
+entry:
+  br label %arrayctor.loop
+
+arrayctor.loop:                                   ; preds = %invoke.cont, %entry
+  %arrayctor.cur = phi i32* [ %foo, %entry ], [ %arrayctor.next, %invoke.cont ]
+  invoke void @g(i32* null)
+          to label %invoke.cont unwind label %lpad
+
+invoke.cont:                                      ; preds = %arrayctor.loop
+  %arrayctor.next = getelementptr inbounds i32* %arrayctor.cur, i64 1
+  %arrayctor.done = icmp eq i32* %arrayctor.next, null
+  br label %arrayctor.loop
+
+lpad:                                             ; preds = %arrayctor.loop
+  %tmp2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+          cleanup
+  ret void
+}
+
+declare i32 @__gxx_personality_v0(...)
+
+declare void @g(i32*)
+
+%"class.std::list" = type { %"class.std::_List_base" }
+%"class.std::_List_base" = type { %"struct.std::_List_base<double, std::allocator<double> >::_List_impl" }
+%"struct.std::_List_base<double, std::allocator<double> >::_List_impl" = type { %"struct.std::__detail::_List_node_base" }
+%"struct.std::__detail::_List_node_base" = type { i8 }
+
+define i32 @_Z15number_of_testsi(i32 %size, i64 %foo, double* %xyz) uwtable {
+entry:
+  %add.ptr.i4 = getelementptr inbounds double* %xyz, i64 %foo
+  br label %for.body.i.i.i.i
+
+for.body.i.i.i.i:                                 ; preds = %.noexc1, %entry
+  %incdec.ptr13.i.i.i.i = phi double* [ %incdec.ptr.i.i.i.i, %.noexc1 ], [ %xyz, %entry ]
+  invoke void @_ZNSt4listIdSaIdEE9push_backERKd(%"class.std::list"* undef, double* %incdec.ptr13.i.i.i.i)
+          to label %.noexc1 unwind label %lpad
+
+.noexc1:                                          ; preds = %for.body.i.i.i.i
+  %incdec.ptr.i.i.i.i = getelementptr inbounds double* %incdec.ptr13.i.i.i.i, i32 1
+  %cmp.i.i.i.i = icmp eq double* %incdec.ptr.i.i.i.i, %add.ptr.i4
+  br label %for.body.i.i.i.i
+
+lpad:                                             ; preds = %for.body.i.i.i.i
+  %lpad.us-lcssa5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+          cleanup
+  resume { i8*, i32 } undef
+}
+
+declare void @_ZNSt4listIdSaIdEE9push_backERKd(%"class.std::list"*, double*)
