[SCCP] Simplify CFG in SCCP as well

[nikic]

Summary

Currently, we only remove dead blocks and non-feasible edges in IPSCCP, but not in SCCP. I'm not aware of any strong reason for that difference, so this patch updates SCCP to perform the CFG cleanup as well.

Compile-time impact seems to be pretty minimal: http://llvm-compile-time-tracker.com/compare.php?from=f65c88c42fdd0e46d16fe31737e6627c56de77c3&to=d9d221a4687368b26083ca34a230e69f9f0fb59b&stat=instructions

For the test case from https://reviews.llvm.org/D126962#3611579 the result after -sccp now looks like this: https://gist.github.com/nikic/d50c03ec140bf9de217c9960d4f60a08 -jump-threading does nothing on this, but -simplifycfg will produce the optimal result.

[fhahn]

LGTM, cleaning up unreachable block here early seems reasonable to me as it doesn't seems to be a big compile-time hit, thanks!

[cfang]

This patch triggered a correctness issue in running mixbench-ocl-alt.
I am not familiar with the CFG in SCCP pass at all. But the comments
in the code seems suggest we should not change the CFG:

If we decided that there are basic blocks that are dead in this function,
delete their contents now. Note that we cannot actually delete the blocks,
// as we cannot modify the CFG of the function.

[fhahn]

In D128796#3645816, @cfang wrote:

This patch triggered a correctness issue in running mixbench-ocl-alt.
I am not familiar with the CFG in SCCP pass at all. But the comments
in the code seems suggest we should not change the CFG:

If we decided that there are basic blocks that are dead in this function,
delete their contents now. Note that we cannot actually delete the blocks,
// as we cannot modify the CFG of the function.

The comment should be irrelevant, the pass is not longer claiming to preserve the CFG, so that should be fine. If there is an incorrect transformation happening, we would need a reproducer.

llvm/lib/Transforms/Scalar/SCCP.cpp

if (tryToReplaceWithConstant(Solver, &Inst)) {
         InstReplacedStat++;
         MadeChanges = true;
       }
     }
   }
   return MadeChanges;
 }
 
+static bool removeNonFeasibleEdges(const SCCPSolver &Solver, BasicBlock *BB,
+                                   DomTreeUpdater &DTU,
+                                   BasicBlock *&NewUnreachableBB);
+
 // runSCCP() - Run the Sparse Conditional Constant Propagation algorithm,
 // and return true if the function was modified.
 static bool runSCCP(Function &F, const DataLayout &DL,
-                    const TargetLibraryInfo *TLI) {
+                    const TargetLibraryInfo *TLI, DomTreeUpdater &DTU) {
   LLVM_DEBUG(dbgs() << "SCCP on function '" << F.getName() << "'\n");
   SCCPSolver Solver(
       DL, [TLI](Function &F) -> const TargetLibraryInfo & { return *TLI; },
       F.getContext());
 
   // Mark the first block of the function as being executable.
   Solver.markBlockExecutable(&F.front());
 
static bool runSCCP(Function &F, const DataLayout &DL,
 
   bool MadeChanges = false;
 
   // If we decided that there are basic blocks that are dead in this function,
   // delete their contents now.  Note that we cannot actually delete the blocks,
   // as we cannot modify the CFG of the function.
 
   SmallPtrSet<Value *, 32> InsertedValues;
+  SmallVector<BasicBlock *, 8> BlocksToErase;
   for (BasicBlock &BB : F) {
     if (!Solver.isBlockExecutable(&BB)) {
       LLVM_DEBUG(dbgs() << "  BasicBlock Dead:" << BB);
-
       ++NumDeadBlocks;
-      NumInstRemoved += removeAllNonTerminatorAndEHPadInstructions(&BB).first;
-
+      BlocksToErase.push_back(&BB);
       MadeChanges = true;
       continue;
     }
 
     MadeChanges |= simplifyInstsInBlock(Solver, BB, InsertedValues,
                                         NumInstRemoved, NumInstReplaced);
   }
 
+  // Remove unreachable blocks and non-feasible edges.
+  for (BasicBlock *DeadBB : BlocksToErase)
+    NumInstRemoved += changeToUnreachable(DeadBB->getFirstNonPHI(),
+                                          /*PreserveLCSSA=*/false, &DTU);
+
+  BasicBlock *NewUnreachableBB = nullptr;
+  for (BasicBlock &BB : F)
+    MadeChanges |= removeNonFeasibleEdges(Solver, &BB, DTU, NewUnreachableBB);
+
+  for (BasicBlock *DeadBB : BlocksToErase)
+    if (!DeadBB->hasAddressTaken())
+      DTU.deleteBB(DeadBB);
+
   return MadeChanges;
 }
 
 PreservedAnalyses SCCPPass::run(Function &F, FunctionAnalysisManager &AM) {
   const DataLayout &DL = F.getParent()->getDataLayout();
   auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
-  if (!runSCCP(F, DL, &TLI))
+  auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
+  DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);
+  if (!runSCCP(F, DL, &TLI, DTU))
     return PreservedAnalyses::all();
 
   auto PA = PreservedAnalyses();
-  PA.preserveSet<CFGAnalyses>();
+  PA.preserve<DominatorTreeAnalysis>();
   return PA;
 }
 
 namespace {
 
 //===--------------------------------------------------------------------===//
 //
 /// SCCP Class - This class uses the SCCPSolver to implement a per-function
 /// Sparse Conditional Constant Propagator.
 ///
 class SCCPLegacyPass : public FunctionPass {
 public:
   // Pass identification, replacement for typeid
   static char ID;
 
   SCCPLegacyPass() : FunctionPass(ID) {
     initializeSCCPLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     AU.addPreserved<GlobalsAAWrapperPass>();
-    AU.setPreservesCFG();
+    AU.addPreserved<DominatorTreeWrapperPass>();
   }
 
   // runOnFunction - Run the Sparse Conditional Constant Propagation
   // algorithm, and return true if the function was modified.
   bool runOnFunction(Function &F) override {
     if (skipFunction(F))
       return false;
     const DataLayout &DL = F.getParent()->getDataLayout();
     const TargetLibraryInfo *TLI =
         &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
-    return runSCCP(F, DL, TLI);
+    auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
+    DomTreeUpdater DTU(DTWP ? &DTWP->getDomTree() : nullptr,
+                       DomTreeUpdater::UpdateStrategy::Lazy);
+    return runSCCP(F, DL, TLI, DTU);
   }
 };
 
 } // end anonymous namespace
 
 char SCCPLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(SCCPLegacyPass, "sccp",

llvm/test/Transforms/GVN/gvn-loop-load-pre-order.ll

 ;
 ; CHECK-SCCP-LABEL: @main(
 ; CHECK-SCCP-NEXT:  entry:
 ; CHECK-SCCP-NEXT:    store i32 0, i32* @b, align 4
 ; CHECK-SCCP-NEXT:    br label [[WHILE_BODY3:%.*]]
 ; CHECK-SCCP:       while.cond.loopexit.loopexit:
 ; CHECK-SCCP-NEXT:    ret void
 ; CHECK-SCCP:       while.body3:
-; CHECK-SCCP-NEXT:    br i1 true, label [[IF_END:%.*]], label [[IF_THEN:%.*]]
-; CHECK-SCCP:       if.then:
-; CHECK-SCCP-NEXT:    br label [[IF_END]]
+; CHECK-SCCP-NEXT:    br label [[IF_END:%.*]]
 ; CHECK-SCCP:       if.end:
 ; CHECK-SCCP-NEXT:    br i1 [[COND:%.*]], label [[WHILE_COND_LOOPEXIT_LOOPEXIT:%.*]], label [[WHILE_BODY3]]
 ;
 entry:
   store i32 0, i32* @b
   br label %while.body3.lr.ph
 
 while.cond.loopexit.loopexit:                     ; preds = %if.end

llvm/test/Transforms/SCCP/2004-12-10-UndefBranchBug.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=sccp -S | FileCheck %s
 
 ; Branch on undef is UB, so the T block is never executed, and we can return
 ; undef (IPSCCP would replace the block with unreachable).
 
 define i32 @foo() {
 ; CHECK-LABEL: @foo(
-; CHECK-NEXT:    br i1 undef, label [[T:%.*]], label [[T]]
-; CHECK:       T:
-; CHECK-NEXT:    ret i32 undef
+; CHECK-NEXT:    unreachable
 ;
   br i1 undef, label %T, label %T
 T:
   %X = add i32 0, 1
   ret i32 %X
 }
 

llvm/test/Transforms/SCCP/2008-01-27-UndefCorrelate.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=sccp -S | FileCheck %s
 ; PR1938
 
 define i32 @main() {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[BB:%.*]]
 ; CHECK:       bb:
-; CHECK-NEXT:    br i1 undef, label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
-; CHECK:       cond_true:
-; CHECK-NEXT:    br i1 undef, label [[BB_BACKEDGE:%.*]], label [[BB12:%.*]]
-; CHECK:       bb.backedge:
-; CHECK-NEXT:    br label [[BB]]
-; CHECK:       cond_false:
-; CHECK-NEXT:    br i1 undef, label [[BB_BACKEDGE]], label [[BB12]]
-; CHECK:       bb12:
-; CHECK-NEXT:    br i1 undef, label [[COND_NEXT18:%.*]], label [[COND_TRUE17:%.*]]
-; CHECK:       cond_true17:
 ; CHECK-NEXT:    unreachable
-; CHECK:       cond_next18:
-; CHECK-NEXT:    ret i32 0
 ;
 entry:
   br label %bb
 
 bb:
   %indvar = phi i32 [ 0, %entry ], [ %k, %bb.backedge ]
   %k = add i32 %indvar, 1
   br i1 undef, label %cond_true, label %cond_false

llvm/test/Transforms/SCCP/preserve-analysis.ll

 ; RUN: opt < %s -debug-pass-manager -passes='loop-vectorize,sccp,loop-vectorize' 2>&1 -S | FileCheck --check-prefix=NEW-PM %s
 
-; Check CFG-only analysis are preserved by SCCP by running it between 2
+; Check that DT is preserved by SCCP by running it between 2
 ; loop-vectorize runs.
 
 ; NEW-PM-DAG: Running analysis: LoopAnalysis on test
 ; NEW-PM-DAG: Running analysis: DominatorTreeAnalysis on test
 ; NEW-PM: Running pass: SCCPPass on test
 ; NEW-PM: Running analysis: TargetLibraryAnalysis on test
-; NEW-PM-NOT: Running analysis: LoopAnalysis on test
+; NEW-PM: Running analysis: LoopAnalysis on test
 ; NEW-PM-NOT: Running analysis: DominatorTreeAnalysis on test
 ; NEW-PM-NOT: Running analysis: AssumptionAnalysis on test
 ; NEW-PM-NOT: Running analysis: TargetLibraryAnalysis on test
 ; NEW-PM-NOT: Running analysis: TargetIRAnalysis on test
 
 
 define i32 @test() {
 entry:
   %res = add i32 1, 10
   ret i32 %res
 }

llvm/test/Transforms/SCCP/sccptest.ll

 ; This is the test case taken from appel's book that illustrates a hard case
 ; that SCCP gets right.
 ;
 define i32 @test2(i32 %i0, i32 %j0) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:  BB1:
 ; CHECK-NEXT:    br label [[BB2:%.*]]
 ; CHECK:       BB2:
-; CHECK-NEXT:    [[K2:%.*]] = phi i32 [ [[K4:%.*]], [[BB7:%.*]] ], [ 0, [[BB1:%.*]] ]
+; CHECK-NEXT:    [[K2:%.*]] = phi i32 [ [[K3:%.*]], [[BB7:%.*]] ], [ 0, [[BB1:%.*]] ]
 ; CHECK-NEXT:    [[KCOND:%.*]] = icmp slt i32 [[K2]], 100
 ; CHECK-NEXT:    br i1 [[KCOND]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       BB3:
-; CHECK-NEXT:    br i1 true, label [[BB5:%.*]], label [[BB6:%.*]]
+; CHECK-NEXT:    br label [[BB5:%.*]]
 ; CHECK:       BB4:
 ; CHECK-NEXT:    ret i32 1
 ; CHECK:       BB5:
-; CHECK-NEXT:    [[K3:%.*]] = add i32 [[K2]], 1
-; CHECK-NEXT:    br label [[BB7]]
-; CHECK:       BB6:
+; CHECK-NEXT:    [[K3]] = add i32 [[K2]], 1
 ; CHECK-NEXT:    br label [[BB7]]
 ; CHECK:       BB7:
-; CHECK-NEXT:    [[K4]] = phi i32 [ [[K3]], [[BB5]] ], [ undef, [[BB6]] ]
 ; CHECK-NEXT:    br label [[BB2]]
 ;
 BB1:
   br label %BB2
 BB2:
   %j2 = phi i32 [ %j4, %BB7 ], [ 1, %BB1 ]
   %k2 = phi i32 [ %k4, %BB7 ], [ 0, %BB1 ]
   %kcond = icmp slt i32 %k2, 100

llvm/test/Transforms/SCCP/strictfp-phis-fcmp.ll

 }
 
 define i1 @float.4_unreachable.defaultenv(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.defaultenv(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
-; CHECK:       dead:
-; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.ignore") #[[ATTR0]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 

 }
 
 define i1 @float.4_unreachable.maytrap(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.maytrap(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
-; CHECK:       dead:
-; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.maytrap") #[[ATTR0]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 

 
 ; FIXME: It's a shame we can't eliminate this fcmp here:
 define i1 @float.4_unreachable.strict(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.strict(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
-; CHECK:       dead:
-; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmp.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 

llvm/test/Transforms/SCCP/strictfp-phis-fcmps.ll

 }
 
 define i1 @float.4_unreachable.defaultenv(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.defaultenv(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
-; CHECK:       dead:
-; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.ignore") #[[ATTR0]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 

 }
 
 define i1 @float.4_unreachable.maytrap(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.maytrap(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
-; CHECK:       dead:
-; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.maytrap") #[[ATTR0]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 

 
 ; FIXME: It's a shame we can't eliminate this fcmps here:
 define i1 @float.4_unreachable.strict(float %f, i1 %cmp) #0 {
 ; CHECK-LABEL: @float.4_unreachable.strict(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP:%.*]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
-; CHECK:       dead:
-; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @llvm.experimental.constrained.fcmps.f32(float 1.000000e+00, float 1.000000e+00, metadata !"une", metadata !"fpexcept.strict") #[[ATTR0]]
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
 
 entry:
   br i1 %cmp, label %if.true, label %end
 

llvm/test/Transforms/SCCP/widening.ll

 ; SCCP-NEXT:    [[C_2:%.*]] = call i1 @cond()
 ; SCCP-NEXT:    br i1 [[C_2]], label [[EXIT]], label [[BB2:%.*]]
 ; SCCP:       bb2:
 ; SCCP-NEXT:    [[C_3:%.*]] = call i1 @cond()
 ; SCCP-NEXT:    br i1 [[C_3]], label [[BB3:%.*]], label [[EXIT]]
 ; SCCP:       bb3:
 ; SCCP-NEXT:    br label [[EXIT]]
 ; SCCP:       exit:
-; SCCP-NEXT:    [[P:%.*]] = phi i32 [ 1, [[ENTRY:%.*]] ], [ 3, [[BB1]] ], [ 2, [[BB2]] ], [ 5, [[BB3]] ], [ [[A:%.*]], [[EXIT]] ]
-; SCCP-NEXT:    [[A]] = add i32 [[P]], 1
+; SCCP-NEXT:    [[P:%.*]] = phi i32 [ 1, [[ENTRY:%.*]] ], [ 3, [[BB1]] ], [ 2, [[BB2]] ], [ 5, [[BB3]] ]
+; SCCP-NEXT:    [[A:%.*]] = add i32 [[P]], 1
 ; SCCP-NEXT:    call void @use(i1 true)
 ; SCCP-NEXT:    call void @use(i1 false)
-; SCCP-NEXT:    br i1 false, label [[EXIT]], label [[EXIT_1:%.*]]
+; SCCP-NEXT:    br label [[EXIT_1:%.*]]
 ; SCCP:       exit.1:
 ; SCCP-NEXT:    ret void
 ;
 ; IPSCCP-LABEL: @rotated_loop_2(
 ; IPSCCP-NEXT:  entry:
 ; IPSCCP-NEXT:    [[C_1:%.*]] = call i1 @cond()
 ; IPSCCP-NEXT:    br i1 [[C_1]], label [[EXIT:%.*]], label [[BB1:%.*]]
 ; IPSCCP:       bb1:

 ; SCCP:       bb3:
 ; SCCP-NEXT:    unreachable
 ; SCCP:       bb4:
 ; SCCP-NEXT:    [[TMP5:%.*]] = add i64 [[TMP2]], 3
 ; SCCP-NEXT:    [[TMP6:%.*]] = and i64 [[TMP5]], 3
 ; SCCP-NEXT:    [[TMP7:%.*]] = sub i64 3, [[TMP6]]
 ; SCCP-NEXT:    [[TMP8:%.*]] = shl i64 [[TMP7]], 1
 ; SCCP-NEXT:    [[TMP9:%.*]] = trunc i64 [[TMP8]] to i32
-; SCCP-NEXT:    [[TMP0:%.*]] = zext i32 [[TMP9]] to i64
+; SCCP-NEXT:    [[TMP10:%.*]] = zext i32 [[TMP9]] to i64
 ; SCCP-NEXT:    br label [[BB11:%.*]]
 ; SCCP:       bb11:
-; SCCP-NEXT:    [[TMP12:%.*]] = phi i64 [ [[TMP0]], [[BB4]] ], [ [[TMP17:%.*]], [[BB18:%.*]] ]
+; SCCP-NEXT:    [[TMP12:%.*]] = phi i64 [ [[TMP10]], [[BB4]] ], [ [[TMP17:%.*]], [[BB18:%.*]] ]
 ; SCCP-NEXT:    br label [[BB13:%.*]]
 ; SCCP:       bb13:
 ; SCCP-NEXT:    [[C_1:%.*]] = icmp eq i64 [[TMP12]], 6
 ; SCCP-NEXT:    br i1 [[C_1]], label [[BB15:%.*]], label [[BB16:%.*]]
 ; SCCP:       bb15:
 ; SCCP-NEXT:    unreachable
 ; SCCP:       bb16:
 ; SCCP-NEXT:    [[TMP17]] = add i64 [[TMP12]], 2

 ; IPSCCP:       bb3:
 ; IPSCCP-NEXT:    unreachable
 ; IPSCCP:       bb4:
 ; IPSCCP-NEXT:    [[TMP5:%.*]] = add i64 [[TMP2]], 3
 ; IPSCCP-NEXT:    [[TMP6:%.*]] = and i64 [[TMP5]], 3
 ; IPSCCP-NEXT:    [[TMP7:%.*]] = sub i64 3, [[TMP6]]
 ; IPSCCP-NEXT:    [[TMP8:%.*]] = shl i64 [[TMP7]], 1
 ; IPSCCP-NEXT:    [[TMP9:%.*]] = trunc i64 [[TMP8]] to i32
-; IPSCCP-NEXT:    [[TMP0:%.*]] = zext i32 [[TMP9]] to i64
+; IPSCCP-NEXT:    [[TMP10:%.*]] = zext i32 [[TMP9]] to i64
 ; IPSCCP-NEXT:    br label [[BB11:%.*]]
 ; IPSCCP:       bb11:
-; IPSCCP-NEXT:    [[TMP12:%.*]] = phi i64 [ [[TMP0]], [[BB4]] ], [ [[TMP17:%.*]], [[BB18:%.*]] ]
+; IPSCCP-NEXT:    [[TMP12:%.*]] = phi i64 [ [[TMP10]], [[BB4]] ], [ [[TMP17:%.*]], [[BB18:%.*]] ]
 ; IPSCCP-NEXT:    br label [[BB13:%.*]]
 ; IPSCCP:       bb13:
 ; IPSCCP-NEXT:    [[C_1:%.*]] = icmp eq i64 [[TMP12]], 6
 ; IPSCCP-NEXT:    br i1 [[C_1]], label [[BB15:%.*]], label [[BB16:%.*]]
 ; IPSCCP:       bb15:
 ; IPSCCP-NEXT:    unreachable
 ; IPSCCP:       bb16:
 ; IPSCCP-NEXT:    [[TMP17]] = add i64 [[TMP12]], 2