[CallSiteSplitting] Pass list of (BB, Conditions) pairs to splitCallSite.

[fhahn]

Summary

This removes some duplication from splitCallSite and makes it easier to
add additional code dealing with each predecessor. It also allows us to
split for more than 2 predecessors, although that is not enabled for
now.

[junbuml]

Sorry for the late response. Just minor comments.

lib/Transforms/Scalar/CallSiteSplitting.cpp

112

Why don't we use 2 instead of 3?

152

Why not use ConditionsTy here ?

282–283

It appears that this loop can be merged into the above loop (line 251), and then we can remove SplitInfo.

[fhahn]

Thanks Jun! I've removed the extra loop dealing with the call PHI node

[fhahn]

lib/Transforms/Scalar/CallSiteSplitting.cpp

112

We potentially record more than 2 conditions now I think and I thought 3 might be better suited to avoid dynamic allocations. I am happy to change it to 2 if you prefer that.

152

This function does not require knowing the size of the SmallVector, so I thought there is no need to make the type more restrictive. I am happy to change it if you prefer that

[junbuml]

LGTM !

lib/Transforms/Scalar/CallSiteSplitting.cpp

112

I'm okay with 3, but I don't think this change increase the possibility of recording more than 2 conditions through single predecessors.

152

As it's used only with ConditionsTy tightly in our current implementation, I may prefer to be consistent with ConditionsTy for now.

282–283

Thanks for handling this.

[fhahn]

Thanks again Jun! I've committed, addressing your 2 suggestions.

lib/Transforms/Scalar/CallSiteSplitting.cpp

 
 using namespace llvm;
 using namespace PatternMatch;
 
 #define DEBUG_TYPE "callsite-splitting"
 
 STATISTIC(NumCallSiteSplit, "Number of call-site split");
 
-static void addNonNullAttribute(Instruction *CallI, Instruction *NewCallI,
-                                Value *Op) {
-  CallSite CS(NewCallI);
+static void addNonNullAttribute(CallSite CS, Value *Op) {
   unsigned ArgNo = 0;
   for (auto &I : CS.args()) {
     if (&*I == Op)
       CS.addParamAttr(ArgNo, Attribute::NonNull);
     ++ArgNo;
   }
 }
 
-static void setConstantInArgument(Instruction *CallI, Instruction *NewCallI,
-                                  Value *Op, Constant *ConstValue) {
-  CallSite CS(NewCallI);
+static void setConstantInArgument(CallSite CS, Value *Op,
+                                  Constant *ConstValue) {
   unsigned ArgNo = 0;
   for (auto &I : CS.args()) {
     if (&*I == Op)
       CS.setArgument(ArgNo, ConstValue);
     ++ArgNo;
   }
 }
 
 static bool isCondRelevantToAnyCallArgument(ICmpInst *Cmp, CallSite CS) {
   assert(isa<Constant>(Cmp->getOperand(1)) && "Expected a constant operand.");
   Value *Op0 = Cmp->getOperand(0);
   unsigned ArgNo = 0;
   for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); I != E;
        ++I, ++ArgNo) {
     // Don't consider constant or arguments that are already known non-null.
     if (isa<Constant>(*I) || CS.paramHasAttr(ArgNo, Attribute::NonNull))
       continue;
 
     if (*I == Op0)
       return true;
   }
   return false;
 }
 
+typedef std::pair<ICmpInst *, unsigned> ConditionTy;
+typedef SmallVector<ConditionTy, 3> ConditionsTy;
+
 /// If From has a conditional jump to To, add the condition to Conditions,
 /// if it is relevant to any argument at CS.
-static void
-recordCondition(const CallSite &CS, BasicBlock *From, BasicBlock *To,
-                SmallVectorImpl<std::pair<ICmpInst *, unsigned>> &Conditions) {
+static void recordCondition(CallSite CS, BasicBlock *From, BasicBlock *To,
+                            ConditionsTy &Conditions) {
   auto *BI = dyn_cast<BranchInst>(From->getTerminator());
   if (!BI || !BI->isConditional())
     return;
 
   CmpInst::Predicate Pred;
   Value *Cond = BI->getCondition();
   if (!match(Cond, m_ICmp(Pred, m_Value(), m_Constant())))
     return;
 
   ICmpInst *Cmp = cast<ICmpInst>(Cond);
   if (Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE)
     if (isCondRelevantToAnyCallArgument(Cmp, CS))
       Conditions.push_back({Cmp, From->getTerminator()->getSuccessor(0) == To
                                      ? Pred
                                      : Cmp->getInversePredicate()});
 }
 
 /// Record ICmp conditions relevant to any argument in CS following Pred's
 /// single successors. If there are conflicting conditions along a path, like
 /// x == 1 and x == 0, the first condition will be used.
-static void
-recordConditions(const CallSite &CS, BasicBlock *Pred,
-                 SmallVectorImpl<std::pair<ICmpInst *, unsigned>> &Conditions) {
+static void recordConditions(CallSite CS, BasicBlock *Pred,
+                             ConditionsTy &Conditions) {
   recordCondition(CS, Pred, CS.getInstruction()->getParent(), Conditions);
   BasicBlock *From = Pred;
   BasicBlock *To = Pred;
   SmallPtrSet<BasicBlock *, 4> Visited = {From};
   while (!Visited.count(From->getSinglePredecessor()) &&
          (From = From->getSinglePredecessor())) {
     recordCondition(CS, From, To, Conditions);
     To = From;
   }
 }
 
-static Instruction *
-addConditions(CallSite &CS,
-              SmallVectorImpl<std::pair<ICmpInst *, unsigned>> &Conditions) {
-  if (Conditions.empty())
-    return nullptr;
-
-  Instruction *NewCI = CS.getInstruction()->clone();
+static void addConditions(CallSite CS,
+                          const SmallVectorImpl<ConditionTy> &Conditions) {
   for (auto &Cond : Conditions) {
     Value *Arg = Cond.first->getOperand(0);
     Constant *ConstVal = cast<Constant>(Cond.first->getOperand(1));
     if (Cond.second == ICmpInst::ICMP_EQ)
-      setConstantInArgument(CS.getInstruction(), NewCI, Arg, ConstVal);
+      setConstantInArgument(CS, Arg, ConstVal);
     else if (ConstVal->getType()->isPointerTy() && ConstVal->isNullValue()) {
       assert(Cond.second == ICmpInst::ICMP_NE);
-      addNonNullAttribute(CS.getInstruction(), NewCI, Arg);
+      addNonNullAttribute(CS, Arg);
     }
   }
-  return NewCI;
 }
 
 static SmallVector<BasicBlock *, 2> getTwoPredecessors(BasicBlock *BB) {
   SmallVector<BasicBlock *, 2> Preds(predecessors((BB)));
   assert(Preds.size() == 2 && "Expected exactly 2 predecessors!");
   return Preds;
 }
 
static bool canSplitCallSite(CallSite CS) {
   SmallVector<BasicBlock *, 2> Preds(predecessors(CallSiteBB));
   if (Preds.size() != 2 || isa<IndirectBrInst>(Preds[0]->getTerminator()) ||
       isa<IndirectBrInst>(Preds[1]->getTerminator()))
     return false;
 
   return CallSiteBB->canSplitPredecessors();
 }
 
-/// Return true if the CS is split into its new predecessors which are directly
-/// hooked to each of its original predecessors pointed by PredBB1 and PredBB2.
-/// CallInst1 and CallInst2 will be the new call-sites placed in the new
-/// predecessors split for PredBB1 and PredBB2, respectively.
+struct SplitInfo {
+  BasicBlock *BB;
+  Instruction *CallInst;
+};
+
+/// Return true if the CS is split into its new predecessors.
+///
+/// For each (predecessor, conditions from predecessors) pair, it will split the
+/// basic block containing the call site, hook it up to the predecessor and
+/// replace the call instruction with new call instructions, which contain
+/// constraints based on the conditions from their predecessors.
 /// For example, in the IR below with an OR condition, the call-site can
-/// be split. Assuming PredBB1=Header and PredBB2=TBB, CallInst1 will be the
-/// call-site placed between Header and Tail, and CallInst2 will be the
-/// call-site between TBB and Tail.
+/// be split. In this case, Preds for Tail is [(Header, a == null),
+/// (TBB, a != null, b == null)]. Tail is replaced by 2 split blocks, containing
+/// CallInst1, which has constraints based on the conditions from Head and
+/// CallInst2, which has constraints based on the conditions coming from TBB.
 ///
 /// From :
 ///
 ///   Header:
 ///     %c = icmp eq i32* %a, null
 ///     br i1 %c %Tail, %TBB
 ///   TBB:
 ///     %c2 = icmp eq i32* %b, null

 ///     %ca2 = call @callee (i32* nonnull %a, i32* null) // CallInst2
 ///    br %Tail
 ///   Tail:
 ///    %p = phi i1 [%ca1, %Tail-split1],[%ca2, %Tail-split2]
 ///
 /// Note that in case any arguments at the call-site are constrained by its
 /// predecessors, new call-sites with more constrained arguments will be
 /// created in createCallSitesOnPredicatedArgument().
-static void splitCallSite(CallSite CS, BasicBlock *PredBB1, BasicBlock *PredBB2,
-                          Instruction *CallInst1, Instruction *CallInst2) {
+static void splitCallSite(
+    CallSite CS,
+    const SmallVectorImpl<std::pair<BasicBlock *, ConditionsTy>> &Preds) {
   Instruction *Instr = CS.getInstruction();
   BasicBlock *TailBB = Instr->getParent();
-  assert(Instr == (TailBB->getFirstNonPHIOrDbg()) && "Unexpected call-site");
-
-  BasicBlock *SplitBlock1 =
-      SplitBlockPredecessors(TailBB, PredBB1, ".predBB1.split");
-  BasicBlock *SplitBlock2 =
-      SplitBlockPredecessors(TailBB, PredBB2, ".predBB2.split");
-
-  assert((SplitBlock1 && SplitBlock2) && "Unexpected new basic block split.");
-
-  if (!CallInst1)
-    CallInst1 = Instr->clone();
-  if (!CallInst2)
-    CallInst2 = Instr->clone();
-
-  CallInst1->insertBefore(&*SplitBlock1->getFirstInsertionPt());
-  CallInst2->insertBefore(&*SplitBlock2->getFirstInsertionPt());
 
-  CallSite CS1(CallInst1);
-  CallSite CS2(CallInst2);
+  DEBUG(dbgs() << "split call-site : " << *Instr << " into \n");
+  SmallVector<SplitInfo, 2> Splits;
+  for (const auto &P : Preds) {
+    BasicBlock *PredBB = P.first;
+    BasicBlock *SplitBlock =
+        SplitBlockPredecessors(TailBB, PredBB, ".predBB.split");
+    assert(SplitBlock && "Unexpected new basic block split.");
+
+    Instruction *NewCI = Instr->clone();
+    CallSite NewCS(NewCI);
+    addConditions(NewCS, P.second);
+    NewCI->insertBefore(&*SplitBlock->getFirstInsertionPt());
 
     // Handle PHIs used as arguments in the call-site.
     for (PHINode &PN : TailBB->phis()) {
       unsigned ArgNo = 0;
       for (auto &CI : CS.args()) {
         if (&*CI == &PN) {
-        CS1.setArgument(ArgNo, PN.getIncomingValueForBlock(SplitBlock1));
-        CS2.setArgument(ArgNo, PN.getIncomingValueForBlock(SplitBlock2));
+          NewCS.setArgument(ArgNo, PN.getIncomingValueForBlock(SplitBlock));
         }
         ++ArgNo;
       }
     }
+    DEBUG(dbgs() << "    " << *NewCI << " in " << SplitBlock->getName()
+                 << "\n");
+    Splits.push_back({SplitBlock, NewCI});
+  }
 
   // Replace users of the original call with a PHI mering call-sites split.
   if (Instr->getNumUses()) {
-    PHINode *PN = PHINode::Create(Instr->getType(), 2, "phi.call",
+    PHINode *CallPN = PHINode::Create(Instr->getType(), 2, "phi.call",
                                       TailBB->getFirstNonPHI());
-    PN->addIncoming(CallInst1, SplitBlock1);
-    PN->addIncoming(CallInst2, SplitBlock2);
-    Instr->replaceAllUsesWith(PN);
+
+    for (auto P : Splits)
+      CallPN->addIncoming(P.CallInst, P.BB);
+    Instr->replaceAllUsesWith(CallPN);
   }
-  DEBUG(dbgs() << "split call-site : " << *Instr << " into \n");
-  DEBUG(dbgs() << "    " << *CallInst1 << " in " << SplitBlock1->getName()
-               << "\n");
-  DEBUG(dbgs() << "    " << *CallInst2 << " in " << SplitBlock2->getName()
-               << "\n");
   Instr->eraseFromParent();
   NumCallSiteSplit++;
 }
 
 // Return true if the call-site has an argument which is a PHI with only
 // constant incoming values.
 static bool isPredicatedOnPHI(CallSite CS) {
   Instruction *Instr = CS.getInstruction();
static bool isPredicatedOnPHI(CallSite CS) {
   return false;
 }
 
 static bool tryToSplitOnPHIPredicatedArgument(CallSite CS) {
   if (!isPredicatedOnPHI(CS))
     return false;
 
   auto Preds = getTwoPredecessors(CS.getInstruction()->getParent());
-  splitCallSite(CS, Preds[0], Preds[1], nullptr, nullptr);
+  SmallVector<std::pair<BasicBlock *, ConditionsTy>, 2> PredsCS = {
+      {Preds[0], {}}, {Preds[1], {}}};
+  splitCallSite(CS, PredsCS);
   return true;
 }
 
 static bool tryToSplitOnPredicatedArgument(CallSite CS) {
   auto Preds = getTwoPredecessors(CS.getInstruction()->getParent());
   if (Preds[0] == Preds[1])
     return false;
 
-  SmallVector<std::pair<ICmpInst *, unsigned>, 2> C1, C2;
-  recordConditions(CS, Preds[0], C1);
-  recordConditions(CS, Preds[1], C2);
+  SmallVector<std::pair<BasicBlock *, ConditionsTy>, 2> PredsCS;
+  for (auto *Pred : make_range(Preds.rbegin(), Preds.rend())) {
+    ConditionsTy Conditions;
+    recordConditions(CS, Pred, Conditions);
+    PredsCS.push_back({Pred, Conditions});
+  }
 
-  Instruction *CallInst1 = addConditions(CS, C1);
-  Instruction *CallInst2 = addConditions(CS, C2);
-  if (!CallInst1 && !CallInst2)
+  if (std::all_of(PredsCS.begin(), PredsCS.end(),
+                  [](const std::pair<BasicBlock *, ConditionsTy> &P) {
+                    return P.second.empty();
+                  }))
     return false;
 
-  splitCallSite(CS, Preds[1], Preds[0], CallInst2, CallInst1);
+  splitCallSite(CS, PredsCS);
   return true;
 }
 
 static bool tryToSplitCallSite(CallSite CS) {
   if (!CS.arg_size() || !canSplitCallSite(CS))
     return false;
   return tryToSplitOnPredicatedArgument(CS) ||
          tryToSplitOnPHIPredicatedArgument(CS);

test/Transforms/CallSiteSplitting/callsite-no-or-structure.ll

 ; RUN: opt < %s -callsite-splitting -S | FileCheck %s
 ; RUN: opt < %s  -passes='function(callsite-splitting)' -S | FileCheck %s
 
 ; CHECK-LABEL: @test_simple
 ; CHECK-LABEL: Header:
-; CHECK-NEXT: br i1 undef, label %Tail.predBB1.split
+; CHECK-NEXT: br i1 undef, label %Tail.predBB.split
 ; CHECK-LABEL: TBB:
-; CHECK: br i1 %cmp, label %Tail.predBB2.split
-; CHECK-LABEL: Tail.predBB1.split:
+; CHECK: br i1 %cmp, label %Tail.predBB.split1
+; CHECK-LABEL: Tail.predBB.split:
 ; CHECK: %[[CALL1:.*]] = call i32 @callee(i32* %a, i32 %v, i32 %p)
-; CHECK-LABEL: Tail.predBB2.split:
+; CHECK-LABEL: Tail.predBB.split1:
 ; CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 %v, i32 %p)
 ; CHECK-LABEL: Tail
-; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ; CHECK: ret i32 %[[MERGED]]
 define i32 @test_simple(i32* %a, i32 %v, i32 %p) {
 Header:
   br i1 undef, label %Tail, label %End
 
 TBB:
   %cmp = icmp eq i32* %a, null
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ; CHECK-LABEL: @test_eq_eq_eq_untaken
 ; CHECK-LABEL: Header:
-; CHECK: br i1 %tobool1, label %TBB1, label %Tail.predBB1.split
+; CHECK: br i1 %tobool1, label %TBB1, label %Tail.predBB.split
 ; CHECK-LABEL: TBB2:
-; CHECK: br i1 %cmp2, label %Tail.predBB2.split, label %End
-; CHECK-LABEL: Tail.predBB1.split:
+; CHECK: br i1 %cmp2, label %Tail.predBB.split1, label %End
+; CHECK-LABEL: Tail.predBB.split:
 ; CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 %p)
-; CHECK-LABEL: Tail.predBB2.split:
+; CHECK-LABEL: Tail.predBB.split1:
 ; CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 1, i32 99)
 ; CHECK-LABEL: Tail
-; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ; CHECK: ret i32 %[[MERGED]]
 define i32 @test_eq_eq_eq_untaken2(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %TBB1, label %Tail
 
 TBB1:
   %cmp1 = icmp eq i32 %v, 1
   br i1 %cmp1, label %TBB2, label %End
 
 TBB2:
   %cmp2 = icmp eq i32 %p, 99
   br i1 %cmp2, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ; CHECK-LABEL: @test_eq_ne_eq_untaken
 ; CHECK-LABEL: Header:
-; CHECK: br i1 %tobool1, label %TBB1, label %Tail.predBB1.split
+; CHECK: br i1 %tobool1, label %TBB1, label %Tail.predBB.split
 ; CHECK-LABEL: TBB2:
-; CHECK: br i1 %cmp2, label %Tail.predBB2.split, label %End
-; CHECK-LABEL: Tail.predBB1.split:
+; CHECK: br i1 %cmp2, label %Tail.predBB.split1, label %End
+; CHECK-LABEL: Tail.predBB.split:
 ; CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 %p)
-; CHECK-LABEL: Tail.predBB2.split:
+; CHECK-LABEL: Tail.predBB.split1:
 ; CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 %v, i32 99)
 ; CHECK-LABEL: Tail
-; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ; CHECK: ret i32 %[[MERGED]]
 define i32 @test_eq_ne_eq_untaken(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %TBB1, label %Tail
 
 TBB1:
   %cmp1 = icmp ne i32 %v, 1
   br i1 %cmp1, label %TBB2, label %End
 
 TBB2:
   %cmp2 = icmp eq i32 %p, 99
   br i1 %cmp2, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ; CHECK-LABEL: @test_header_header2_tbb
 ; CHECK: Header2:
-; CHECK:br i1 %tobool2, label %Tail.predBB1.split, label %TBB1
+; CHECK:br i1 %tobool2, label %Tail.predBB.split, label %TBB1
 ; CHECK-LABEL: TBB2:
-; CHECK: br i1 %cmp2, label %Tail.predBB2.split, label %End
-; CHECK-LABEL: Tail.predBB1.split:
+; CHECK: br i1 %cmp2, label %Tail.predBB.split1, label %End
+; CHECK-LABEL: Tail.predBB.split:
 ; CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 10)
-; CHECK-LABEL: Tail.predBB2.split:
+; CHECK-LABEL: Tail.predBB.split1:
 ; NOTE: CallSiteSplitting cannot infer that %a is null here, as it currently
 ;       only supports recording conditions along a single predecessor path.
 ; CHECK: %[[CALL2:.*]] = call i32 @callee(i32* %a, i32 1, i32 99)
 ; CHECK-LABEL: Tail
-; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+; CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ; CHECK: ret i32 %[[MERGED]]
 define i32 @test_header_header2_tbb(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %TBB1, label %Header2
 
 Header2:
   %tobool2 = icmp eq i32 %p, 10

test/Transforms/CallSiteSplitting/callsite-split-debug.ll

 !6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 4, unit: !0)
 !7 = !DILocalVariable(name: "c", scope: !6, line: 5, type: !5)
 !8 = !DILocation(line: 5, column: 7, scope: !6)
 
 ; The optimization should trigger even in the presence of the dbg.value in
 ; CallSiteBB.
 
 ; CHECK-LABEL: @foo
-; CHECK-LABEL: CallsiteBB.predBB1.split:
+; CHECK-LABEL: CallsiteBB.predBB.split:
 ; CHECK: [[TMP1:%[0-9]+]] = call i16 @bar(i16 1, i16 5)
-; CHECK-LABEL: CallsiteBB.predBB2.split:
+; CHECK-LABEL: CallsiteBB.predBB.split1:
 ; CHECK: [[TMP2:%[0-9]+]] = call i16 @bar(i16 0, i16 5)
 ; CHECK-LABEL: CallsiteBB
-; CHECK: %phi.call = phi i16 [ [[TMP1]], %CallsiteBB.predBB1.split ], [ [[TMP2]], %CallsiteBB.predBB2.split
+; CHECK: %phi.call = phi i16 [ [[TMP1]], %CallsiteBB.predBB.split ], [ [[TMP2]], %CallsiteBB.predBB.split1
 

test/Transforms/CallSiteSplitting/callsite-split-or-phi.ll

 ; RUN: opt < %s -callsite-splitting -S | FileCheck %s
 ; RUN: opt < %s  -passes='function(callsite-splitting)' -S | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-linaro-linux-gnueabi"
 
 ;CHECK-LABEL: @test_eq_eq
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* null, i32 %v, i32 1)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* nonnull %a, i32 1, i32 2)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 1, %Tail.predBB1.split ], [ 2, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 1, %Tail.predBB.split ], [ 2, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_eq_eq(i32* %a, i32 %v) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_eq_eq_eq
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* null, i32 %v, i32 10)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 1, i32 %p)
 ;CHECK-LABEL: Tail
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_eq_eq_eq(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %Header2, label %End
 
 Header2:
   %tobool2 = icmp eq i32 %p, 10
   br i1 %tobool2, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_eq_eq_eq_constrain_same_i32_arg
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* %a, i32 222, i32 %p)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* %a, i32 333, i32 %p)
 ;CHECK-LABEL: Tail
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_eq_eq_eq_constrain_same_i32_arg(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp eq i32 %v, 111
   br i1 %tobool1, label %Header2, label %End
 
 Header2:
   %tobool2 = icmp eq i32 %v, 222
   br i1 %tobool2, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, 333
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_ne_eq
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 1)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 1, i32 2)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 1, %Tail.predBB1.split ], [ 2, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 1, %Tail.predBB.split ], [ 2, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_ne_eq(i32* %a, i32 %v) {
 Header:
   %tobool1 = icmp ne i32* %a, null
   br i1 %tobool1, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_ne_eq_ne
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 10)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 %p)
 ;CHECK-LABEL: Tail
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_ne_eq_ne(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp ne i32* %a, null
   br i1 %tobool1, label %Header2, label %End
 
 Header2:
   %tobool2 = icmp eq i32 %p, 10
   br i1 %tobool2, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp ne i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_ne_ne
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 1)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 %v, i32 2)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 1, %Tail.predBB1.split ], [ 2, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 1, %Tail.predBB.split ], [ 2, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_ne_ne(i32* %a, i32 %v) {
 Header:
   %tobool1 = icmp ne i32* %a, null
   br i1 %tobool1, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp ne i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_ne_ne_ne_constrain_same_pointer_arg
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 %p)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 %p)
 ;CHECK-LABEL: Tail
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_ne_ne_ne_constrain_same_pointer_arg(i32* %a, i32 %v, i32 %p, i32* %a2, i32* %a3) {
 Header:
   %tobool1 = icmp ne i32* %a, null
   br i1 %tobool1, label %Header2, label %End
 
 Header2:
   %tobool2 = icmp ne i32* %a, %a2

 
 End:
   ret i32 %v
 }
 
 
 
 ;CHECK-LABEL: @test_eq_eq_untaken
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 1)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 1, i32 2)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 1, %Tail.predBB1.split ], [ 2, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 1, %Tail.predBB.split ], [ 2, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_eq_eq_untaken(i32* %a, i32 %v) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %TBB, label %Tail
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_eq_eq_eq_untaken
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 10)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* nonnull %a, i32 1, i32 %p)
 ;CHECK-LABEL: Tail
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_eq_eq_eq_untaken(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %End, label %Header2
 
 Header2:
   %tobool2 = icmp eq i32 %p, 10
   br i1 %tobool2, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_ne_eq_untaken
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* null, i32 %v, i32 1)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* nonnull %a, i32 1, i32 2)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 1, %Tail.predBB1.split ], [ 2, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 1, %Tail.predBB.split ], [ 2, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_ne_eq_untaken(i32* %a, i32 %v) {
 Header:
   %tobool1 = icmp ne i32* %a, null
   br i1 %tobool1, label %TBB, label %Tail
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_ne_eq_ne_untaken
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* null, i32 %v, i32 10)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* null, i32 %v, i32 %p)
 ;CHECK-LABEL: Tail
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_ne_eq_ne_untaken(i32* %a, i32 %v, i32 %p) {
 Header:
   %tobool1 = icmp ne i32* %a, null
   br i1 %tobool1, label %End, label %Header2
 
 Header2:
   %tobool2 = icmp eq i32 %p, 10
   br i1 %tobool2, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp ne i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_ne_ne_untaken
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* null, i32 %v, i32 1)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* nonnull %a, i32 1, i32 2)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 1, %Tail.predBB1.split ], [ 2, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 1, %Tail.predBB.split ], [ 2, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_ne_ne_untaken(i32* %a, i32 %v) {
 Header:
   %tobool1 = icmp ne i32* %a, null
   br i1 %tobool1, label %TBB, label %Tail
 
 TBB:
   %cmp = icmp ne i32 %v, 1
   br i1 %cmp, label %End, label %Tail
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_nonconst_const_phi
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* %a, i32 %v, i32 1)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* %a, i32 1, i32 2)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 1, %Tail.predBB1.split ], [ 2, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 1, %Tail.predBB.split ], [ 2, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_nonconst_const_phi(i32* %a, i32* %b, i32 %v) {
 Header:
   %tobool1 = icmp eq i32* %a, %b
   br i1 %tobool1, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_nonconst_nonconst_phi
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* %a, i32 %v, i32 2)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* %a, i32 %v, i32 1)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 2, %Tail.predBB1.split ], [ 1, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 2, %Tail.predBB.split ], [ 1, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_nonconst_nonconst_phi(i32* %a, i32* %b, i32 %v, i32 %v2) {
 Header:
   %tobool1 = icmp eq i32* %a, %b
   br i1 %tobool1, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, %v2 
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_cfg_no_or_phi
-;CHECK-LABEL: Tail.predBB1.split
+;CHECK-LABEL: Tail.predBB.split
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* %a, i32 %v, i32 2)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* %a, i32 %v, i32 1)
 ;CHECK-LABEL: Tail
-;CHECK: %p = phi i32 [ 2, %Tail.predBB1.split ], [ 1, %Tail.predBB2.split ]
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %p = phi i32 [ 2, %Tail.predBB.split ], [ 1, %Tail.predBB.split1 ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_cfg_no_or_phi(i32* %a,  i32 %v) {
 entry:
   br i1 undef, label %TBB0, label %TBB1
 TBB0:
   br i1 undef, label %Tail, label %End
 TBB1:
   br i1 undef, label %Tail, label %End
 Tail:
   %p = phi i32[1,%TBB0], [2, %TBB1]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_nonconst_nonconst_phi_noncost
-;CHECK-NOT: Tail.predBB1.split:
-;CHECK-NOT: Tail.predBB2.split:
+;CHECK-NOT: Tail.predBB.split:
+;CHECK-NOT: Tail.predBB.split1:
 ;CHECK-LABEL: Tail:
 ;CHECK: %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
 ;CHECK: ret i32 %r
 define i32 @test_nonconst_nonconst_phi_noncost(i32* %a, i32* %b, i32 %v, i32 %v2) {
 Header:
   %tobool1 = icmp eq i32* %a, %b
   br i1 %tobool1, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, %v2 
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[%v,%Header], [%v2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_fisrtnonphi
-;CHECK-NOT: Tail.predBB1.split:
-;CHECK-NOT: Tail.predBB2.split:
+;CHECK-NOT: Tail.predBB.split:
+;CHECK-NOT: Tail.predBB.split1:
 ;CHECK-LABEL: Tail:
 ;CHECK: %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
 ;CHECK: ret i32 %r
 define i32 @test_fisrtnonphi(i32* %a, i32 %v) {
 Header:
   %tobool1 = icmp eq i32* %a, null
   br i1 %tobool1, label %Tail, label %TBB
 
 TBB:
   %cmp = icmp eq i32 %v, 1
   br i1 %cmp, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   store i32 %v, i32* %a
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_3preds_constphi
-;CHECK-NOT: Tail.predBB1.split:
-;CHECK-NOT: Tail.predBB2.split:
+;CHECK-NOT: Tail.predBB.split:
+;CHECK-NOT: Tail.predBB.split1:
 ;CHECK-LABEL: Tail:
 ;CHECK: %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
 ;CHECK: ret i32 %r
 define i32 @test_3preds_constphi(i32* %a, i32 %v, i1 %c1, i1 %c2, i1 %c3) {
 Header:
   br i1 %c1, label %Tail, label %TBB1
 
 TBB1:
   br i1 %c2, label %Tail, label %TBB2
 
 TBB2:
   br i1 %c3, label %Tail, label %End
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB1], [3, %TBB2]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_indirectbr_phi
-;CHECK-NOT: Tail.predBB1.split:
-;CHECK-NOT: Tail.predBB2.split:
+;CHECK-NOT: Tail.predBB.split:
+;CHECK-NOT: Tail.predBB.split1:
 ;CHECK-LABEL: Tail:
 ;CHECK: %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
 ;CHECK: ret i32 %r
 define i32 @test_indirectbr_phi(i8* %address, i32* %a, i32* %b, i32 %v) {
 Header:
    %indirect.goto.dest = select i1 undef, i8* blockaddress(@test_indirectbr_phi, %End), i8* %address
    indirectbr i8* %indirect.goto.dest, [label %TBB, label %Tail]
 
 TBB:
   %indirect.goto.dest2 = select i1 undef, i8* blockaddress(@test_indirectbr_phi, %End), i8* %address
   indirectbr i8* %indirect.goto.dest2, [label %Tail, label %End]
 
 Tail:
   %p = phi i32[1,%Header], [2, %TBB]
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
 ;CHECK-LABEL: @test_unreachable
-;CHECK-LABEL: Tail.predBB1.split:
+;CHECK-LABEL: Tail.predBB.split:
 ;CHECK: %[[CALL1:.*]] = call i32 @callee(i32* %a, i32 %v, i32 10)
-;CHECK-LABEL: Tail.predBB2.split:
+;CHECK-LABEL: Tail.predBB.split1:
 ;CHECK: %[[CALL2:.*]] = call i32 @callee(i32* %a, i32 1, i32 %p)
 ;CHECK-LABEL: Tail
-;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB1.split ], [ %[[CALL2]], %Tail.predBB2.split ]
+;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Tail.predBB.split ], [ %[[CALL2]], %Tail.predBB.split1 ]
 ;CHECK: ret i32 %[[MERGED]]
 define i32 @test_unreachable(i32* %a, i32 %v, i32 %p) {
 Entry:
   br label %End
 Header:
   %tobool2 = icmp eq i32 %p, 10
   br i1 %tobool2, label %Tail, label %TBB
 TBB:

test/Transforms/CallSiteSplitting/callsite-split.ll

 ; RUN: opt < %s -callsite-splitting -inline -instcombine -jump-threading -S | FileCheck %s
 ; RUN: opt < %s  -passes='function(callsite-splitting),cgscc(inline),function(instcombine,jump-threading)' -S | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-linaro-linux-gnueabi"
 
 %struct.bitmap = type { i32, %struct.bitmap* }
 
 ;CHECK-LABEL: @caller
 ;CHECK-LABEL: NextCond:
 ;CHECK: br {{.*}} label %callee.exit
-;CHECK-LABEL: CallSiteBB.predBB1.split:
+;CHECK-LABEL: CallSiteBB.predBB.split:
 ;CHECK: call void @callee(%struct.bitmap* null, %struct.bitmap* null, %struct.bitmap* %b_elt, i1 false)
 ;CHECK-LABEL: callee.exit:
 ;CHECK: call void @dummy2(%struct.bitmap* %a_elt)
 
 define void @caller(i1 %c, %struct.bitmap* %a_elt, %struct.bitmap* %b_elt) {
 entry:
   br label %Top
 
End:
   ret void
 }
 
 declare void @dummy2(%struct.bitmap*)
 declare void @dummy1(%struct.bitmap*, %struct.bitmap*, %struct.bitmap*, %struct.bitmap*, %struct.bitmap*, %struct.bitmap*)
 
 
 ;CHECK-LABEL: @caller2
-;CHECK-LABEL: CallSiteBB.predBB1.split:
+;CHECK-LABEL: CallSiteBB.predBB.split:
 ;CHECK: call void @dummy3()
-;CHECK-LABEL: CallSiteBB.predBB2.split:
+;CHECK-LABEL: CallSiteBB.predBB.split1:
 ;CHECK: call void @dummy4()
 ;CheCK-LABEL: CallSiteBB:
-;CHECK: %phi.call = phi i1 [ true, %CallSiteBB.predBB1.split ], [ false, %CallSiteBB.predBB2.split ]
+;CHECK: %phi.call = phi i1 [ true, %CallSiteBB.predBB.split ], [ false, %CallSiteBB.predBB.split1 ]
 ;CHECK: call void @foo(i1 %phi.call)
 define void @caller2(i1 %c, %struct.bitmap* %a_elt, %struct.bitmap* %b_elt, %struct.bitmap* %c_elt) {
 entry:
   br label %Top
 
 Top:
   %tobool1 = icmp eq %struct.bitmap* %a_elt, %b_elt
   br i1 %tobool1, label %CallSiteBB, label %NextCond