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

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.

Reviewers: junbuml, mcrosier, davidxl, davide

Reviewed By: junbuml

Differential Revision: https://reviews.llvm.org/D41858

llvm-svn: 322599

4 files changed, 92 insertions, 92 deletions

diff --git a/llvm/test/Transforms/CallSiteSplitting/callsite-no-or-structure.ll b/llvm/test/Transforms/CallSiteSplitting/callsite-no-or-structure.ll
index e10b04a850a..78c287e78ea 100644
--- a/llvm/test/Transforms/CallSiteSplitting/callsite-no-or-structure.ll
+++ b/llvm/test/Transforms/CallSiteSplitting/callsite-no-or-structure.ll
@@ -3,15 +3,15 @@
 
 ; 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:
@@ -31,15 +31,15 @@ End:
 
 ; 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:
@@ -64,15 +64,15 @@ End:
 
 ; 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:
@@ -97,17 +97,17 @@ End:
 
 ; 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:
diff --git a/llvm/test/Transforms/CallSiteSplitting/callsite-split-debug.ll b/llvm/test/Transforms/CallSiteSplitting/callsite-split-debug.ll
index dbd6cd9cc8d..415b6038f37 100644
--- a/llvm/test/Transforms/CallSiteSplitting/callsite-split-debug.ll
+++ b/llvm/test/Transforms/CallSiteSplitting/callsite-split-debug.ll
@@ -48,10 +48,10 @@ attributes #0 = { nounwind readnone speculatable }
 ; 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
 
diff --git a/llvm/test/Transforms/CallSiteSplitting/callsite-split-or-phi.ll b/llvm/test/Transforms/CallSiteSplitting/callsite-split-or-phi.ll
index e41a81f4b21..56f194f93f7 100644
--- a/llvm/test/Transforms/CallSiteSplitting/callsite-split-or-phi.ll
+++ b/llvm/test/Transforms/CallSiteSplitting/callsite-split-or-phi.ll
@@ -5,13 +5,13 @@ 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:
@@ -32,12 +32,12 @@ End:
 }
 
 ;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:
@@ -61,12 +61,12 @@ End:
 }
 
 ;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:
@@ -90,13 +90,13 @@ End:
 }
 
 ;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:
@@ -117,12 +117,12 @@ End:
 }
 
 ;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:
@@ -146,13 +146,13 @@ End:
 }
 
 ;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:
@@ -173,12 +173,12 @@ End:
 }
 
 ;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:
@@ -204,13 +204,13 @@ End:
 
 
 ;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:
@@ -231,12 +231,12 @@ End:
 }
 
 ;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:
@@ -260,13 +260,13 @@ End:
 }
 
 ;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:
@@ -287,12 +287,12 @@ End:
 }
 
 ;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:
@@ -316,13 +316,13 @@ End:
 }
 
 ;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:
@@ -343,13 +343,13 @@ End:
 }
 
 ;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:
@@ -370,13 +370,13 @@ End:
 }
 
 ;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:
@@ -397,13 +397,13 @@ End:
 }
 
 ;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:
@@ -421,8 +421,8 @@ End:
 }
 
 ;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
@@ -445,8 +445,8 @@ End:
 }
 
 ;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
@@ -470,8 +470,8 @@ End:
 }
 
 ;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
@@ -495,8 +495,8 @@ End:
 }
 
 ;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
@@ -519,12 +519,12 @@ End:
 }
 
 ;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:
diff --git a/llvm/test/Transforms/CallSiteSplitting/callsite-split.ll b/llvm/test/Transforms/CallSiteSplitting/callsite-split.ll
index adc4160cde6..af821690e0a 100644
--- a/llvm/test/Transforms/CallSiteSplitting/callsite-split.ll
+++ b/llvm/test/Transforms/CallSiteSplitting/callsite-split.ll
@@ -9,7 +9,7 @@ target triple = "aarch64-linaro-linux-gnueabi"
 ;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)
@@ -69,12 +69,12 @@ declare void @dummy1(%struct.bitmap*, %struct.bitmap*, %struct.bitmap*, %struct.
 
 
 ;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: