Support unreachable instructions in SimplifyCFG's tail merging.

[nikic]

See discussion on D104870.

[lebedev.ri]

It *really* seems like we should be doing D116692, but the numbers suggest otherwise.

[resistor]

If we definitively don't want to make this change, should we remove the FIXME?

llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp

if (DTU && DTU->isBBPendingDeletion(&BB))
       continue;
 
     // We are only interested in function-terminating blocks.
     if (!succ_empty(&BB))
       continue;
 
     auto *Term = BB.getTerminator();
 
-    // Fow now only support `ret`/`resume` function terminators.
-    // FIXME: lift this restriction.
+    // Support function terminators that have no successors.
     switch (Term->getOpcode()) {
     case Instruction::Ret:
     case Instruction::Resume:
+    case Instruction::Unreachable:
       break;
     default:
       continue;
     }
 
     // We can't tail-merge block that contains a musttail call.
     if (BB.getTerminatingMustTailCall())
       continue;

llvm/test/Transforms/PhaseOrdering/AArch64/peel-multiple-unreachable-exits-for-vectorization.ll

 ; CHECK:       loop.preheader20:
 ; CHECK-NEXT:    [[IV_PH:%.*]] = phi i64 [ 1, [[LOOP_PREHEADER]] ], [ [[IND_END]], [[MIDDLE_BLOCK]] ]
 ; CHECK-NEXT:    [[SUM_PH:%.*]] = phi i64 [ [[SUM_NEXT_PEEL]], [[LOOP_PREHEADER]] ], [ [[TMP15]], [[MIDDLE_BLOCK]] ]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], [[AT_WITH_INT_CONVERSION_EXIT11:%.*]] ], [ [[IV_PH]], [[LOOP_PREHEADER20]] ]
 ; CHECK-NEXT:    [[SUM:%.*]] = phi i64 [ [[SUM_NEXT:%.*]], [[AT_WITH_INT_CONVERSION_EXIT11]] ], [ [[SUM_PH]], [[LOOP_PREHEADER20]] ]
 ; CHECK-NEXT:    [[INRANGE_I:%.*]] = icmp ult i64 [[SUB_I]], [[IV]]
-; CHECK-NEXT:    br i1 [[INRANGE_I]], label [[ERROR_I:%.*]], label [[AT_WITH_INT_CONVERSION_EXIT:%.*]]
-; CHECK:       error.i:
-; CHECK-NEXT:    tail call void @error()
-; CHECK-NEXT:    unreachable
-; CHECK:       at_with_int_conversion.exit:
 ; CHECK-NEXT:    [[INRANGE_I7:%.*]] = icmp ult i64 [[SUB_I6_PEEL]], [[IV]]
-; CHECK-NEXT:    br i1 [[INRANGE_I7]], label [[ERROR_I10:%.*]], label [[AT_WITH_INT_CONVERSION_EXIT11]]
-; CHECK:       error.i10:
+; CHECK-NEXT:    [[OR_COND:%.*]] = select i1 [[INRANGE_I]], i1 true, i1 [[INRANGE_I7]]
+; CHECK-NEXT:    br i1 [[OR_COND]], label [[COMMON_UNREACHABLE:%.*]], label [[AT_WITH_INT_CONVERSION_EXIT11]]
+; CHECK:       common.unreachable:
 ; CHECK-NEXT:    tail call void @error()
 ; CHECK-NEXT:    unreachable
 ; CHECK:       at_with_int_conversion.exit11:
 ; CHECK-NEXT:    [[GEP_IDX_I:%.*]] = getelementptr i64, ptr [[START_I]], i64 [[IV]]
 ; CHECK-NEXT:    [[LV_I:%.*]] = load i64, ptr [[GEP_IDX_I]], align 4
 ; CHECK-NEXT:    [[GEP_IDX_I8:%.*]] = getelementptr i64, ptr [[START_I1_PEEL]], i64 [[IV]]
 ; CHECK-NEXT:    [[LV_I9:%.*]] = load i64, ptr [[GEP_IDX_I8]], align 4
 ; CHECK-NEXT:    [[ADD:%.*]] = add i64 [[LV_I]], [[SUM]]

 ; CHECK:       loop.preheader34:
 ; CHECK-NEXT:    [[IV_PH:%.*]] = phi i64 [ 1, [[LOOP_PREHEADER]] ], [ [[IND_END]], [[MIDDLE_BLOCK]] ]
 ; CHECK-NEXT:    [[SUM_PH:%.*]] = phi i64 [ [[SUM_NEXT_PEEL]], [[LOOP_PREHEADER]] ], [ [[TMP19]], [[MIDDLE_BLOCK]] ]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[IV:%.*]] = phi i64 [ [[IV_NEXT:%.*]], [[AT_WITH_INT_CONVERSION_EXIT22:%.*]] ], [ [[IV_PH]], [[LOOP_PREHEADER34]] ]
 ; CHECK-NEXT:    [[SUM:%.*]] = phi i64 [ [[SUM_NEXT:%.*]], [[AT_WITH_INT_CONVERSION_EXIT22]] ], [ [[SUM_PH]], [[LOOP_PREHEADER34]] ]
 ; CHECK-NEXT:    [[INRANGE_I:%.*]] = icmp ult i64 [[SUB_I]], [[IV]]
-; CHECK-NEXT:    br i1 [[INRANGE_I]], label [[ERROR_I:%.*]], label [[AT_WITH_INT_CONVERSION_EXIT:%.*]]
-; CHECK:       error.i:
+; CHECK-NEXT:    br i1 [[INRANGE_I]], label [[COMMON_UNREACHABLE:%.*]], label [[AT_WITH_INT_CONVERSION_EXIT:%.*]]
+; CHECK:       common.unreachable:
 ; CHECK-NEXT:    tail call void @error()
 ; CHECK-NEXT:    unreachable
 ; CHECK:       at_with_int_conversion.exit:
-; CHECK-NEXT:    [[GEP_IDX_I:%.*]] = getelementptr i64, ptr [[START_I]], i64 [[IV]]
-; CHECK-NEXT:    [[LV_I:%.*]] = load i64, ptr [[GEP_IDX_I]], align 4
 ; CHECK-NEXT:    [[INRANGE_I7:%.*]] = icmp ult i64 [[SUB_I6_PEEL]], [[IV]]
-; CHECK-NEXT:    br i1 [[INRANGE_I7]], label [[ERROR_I10:%.*]], label [[AT_WITH_INT_CONVERSION_EXIT11:%.*]]
-; CHECK:       error.i10:
-; CHECK-NEXT:    tail call void @error()
-; CHECK-NEXT:    unreachable
-; CHECK:       at_with_int_conversion.exit11:
 ; CHECK-NEXT:    [[INRANGE_I18:%.*]] = icmp ult i64 [[SUB_I17_PEEL]], [[IV]]
-; CHECK-NEXT:    br i1 [[INRANGE_I18]], label [[ERROR_I21:%.*]], label [[AT_WITH_INT_CONVERSION_EXIT22]]
-; CHECK:       error.i21:
-; CHECK-NEXT:    tail call void @error()
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    [[OR_COND:%.*]] = select i1 [[INRANGE_I7]], i1 true, i1 [[INRANGE_I18]]
+; CHECK-NEXT:    br i1 [[OR_COND]], label [[COMMON_UNREACHABLE]], label [[AT_WITH_INT_CONVERSION_EXIT22]]
 ; CHECK:       at_with_int_conversion.exit22:
+; CHECK-NEXT:    [[GEP_IDX_I:%.*]] = getelementptr i64, ptr [[START_I]], i64 [[IV]]
+; CHECK-NEXT:    [[LV_I:%.*]] = load i64, ptr [[GEP_IDX_I]], align 4
 ; CHECK-NEXT:    [[GEP_IDX_I8:%.*]] = getelementptr i64, ptr [[START_I1_PEEL]], i64 [[IV]]
 ; CHECK-NEXT:    [[LV_I9:%.*]] = load i64, ptr [[GEP_IDX_I8]], align 4
 ; CHECK-NEXT:    [[GEP_IDX_I19:%.*]] = getelementptr i64, ptr [[START_I12_PEEL]], i64 [[IV]]
 ; CHECK-NEXT:    [[LV_I20:%.*]] = load i64, ptr [[GEP_IDX_I19]], align 4
 ; CHECK-NEXT:    [[ADD_1:%.*]] = add i64 [[LV_I]], [[SUM]]
 ; CHECK-NEXT:    [[ADD_2:%.*]] = add i64 [[ADD_1]], [[LV_I9]]
 ; CHECK-NEXT:    [[SUM_NEXT]] = add i64 [[ADD_2]], [[LV_I20]]
 ; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1

llvm/test/Transforms/SimplifyCFG/tail-merge-assert.ll

 @.str.3 = private unnamed_addr constant [11 x i8] c"y - x < 40\00", align 1
 
 declare void @glibc_assert_fail(ptr, ptr, i32, ptr)
 
 define void @merge_glibc_asserts(i32 %x, i32 %y) {
 ; CHECK-LABEL: @merge_glibc_asserts(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i32 [[Y:%.*]], [[X:%.*]]
-; CHECK-NEXT:    br i1 [[CMP]], label [[COND_END:%.*]], label [[COND_FALSE:%.*]]
-; CHECK:       cond.false:
-; CHECK-NEXT:    tail call void @glibc_assert_fail(ptr @.str, ptr @.str.1, i32 3, ptr @__PRETTY_FUNCTION__._Z1fjj)
+; CHECK-NEXT:    br i1 [[CMP]], label [[COND_END:%.*]], label [[COMMON_UNREACHABLE:%.*]]
+; CHECK:       common.unreachable:
+; CHECK-NEXT:    [[DOTSINK:%.*]] = phi i32 [ 3, [[ENTRY:%.*]] ], [ 4, [[COND_END]] ], [ 5, [[COND_END4:%.*]] ]
+; CHECK-NEXT:    [[DOTSTR_3_SINK:%.*]] = phi ptr [ @.str, [[ENTRY]] ], [ @.str.2, [[COND_END]] ], [ @.str.3, [[COND_END4]] ]
+; CHECK-NEXT:    tail call void @glibc_assert_fail(ptr [[DOTSTR_3_SINK]], ptr @.str.1, i32 [[DOTSINK]], ptr @__PRETTY_FUNCTION__._Z1fjj)
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cond.end:
 ; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[Y]], [[X]]
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i32 [[SUB]], 7
-; CHECK-NEXT:    br i1 [[CMP1]], label [[COND_END4:%.*]], label [[COND_FALSE3:%.*]]
-; CHECK:       cond.false3:
-; CHECK-NEXT:    tail call void @glibc_assert_fail(ptr @.str.2, ptr @.str.1, i32 4, ptr @__PRETTY_FUNCTION__._Z1fjj)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[CMP1]], label [[COND_END4]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cond.end4:
 ; CHECK-NEXT:    [[CMP6:%.*]] = icmp ult i32 [[SUB]], 40
-; CHECK-NEXT:    br i1 [[CMP6]], label [[COND_END9:%.*]], label [[COND_FALSE8:%.*]]
-; CHECK:       cond.false8:
-; CHECK-NEXT:    tail call void @glibc_assert_fail(ptr @.str.3, ptr @.str.1, i32 5, ptr @__PRETTY_FUNCTION__._Z1fjj)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[CMP6]], label [[COND_END9:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cond.end9:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %cmp = icmp ugt i32 %y, %x
   br i1 %cmp, label %cond.end, label %cond.false
 
 cond.false:                                       ; preds = %entry

llvm/test/Transforms/SimplifyCFG/tail-merge-noreturn.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=simplifycfg -simplifycfg-require-and-preserve-domtree=1 -sink-common-insts  -S < %s | FileCheck %s
 
 ; Test that we tail merge noreturn call blocks and phi constants properly.
 
 declare void @abort()
 declare void @assert_fail_1(i32)
 declare void @assert_fail_1_alt(i32)
 
 define void @merge_simple() {
 ; CHECK-LABEL: @merge_simple(
 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[A1:%.*]]
-; CHECK:       a1:
+; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[COMMON_UNREACHABLE:%.*]]
+; CHECK:       common.unreachable:
 ; CHECK-NEXT:    call void @assert_fail_1(i32 0)
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cont1:
 ; CHECK-NEXT:    [[C2:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[A2:%.*]]
-; CHECK:       a2:
-; CHECK-NEXT:    call void @assert_fail_1(i32 0)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont2:
 ; CHECK-NEXT:    [[C3:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[A3:%.*]]
-; CHECK:       a3:
-; CHECK-NEXT:    call void @assert_fail_1(i32 0)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont3:
 ; CHECK-NEXT:    ret void
 ;
   %c1 = call i1 @foo()
   br i1 %c1, label %cont1, label %a1
 a1:
   call void @assert_fail_1(i32 0)
   unreachable

 cont3:
   ret void
 }
 
 define void @phi_three_constants() {
 ; CHECK-LABEL: @phi_three_constants(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[A1:%.*]]
-; CHECK:       a1:
-; CHECK-NEXT:    call void @assert_fail_1(i32 0)
+; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[COMMON_UNREACHABLE:%.*]]
+; CHECK:       common.unreachable:
+; CHECK-NEXT:    [[DOTSINK:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 1, [[CONT1]] ], [ 2, [[CONT2:%.*]] ]
+; CHECK-NEXT:    call void @assert_fail_1(i32 [[DOTSINK]])
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cont1:
 ; CHECK-NEXT:    [[C2:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[A2:%.*]]
-; CHECK:       a2:
-; CHECK-NEXT:    call void @assert_fail_1(i32 1)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[C2]], label [[CONT2]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont2:
 ; CHECK-NEXT:    [[C3:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[A3:%.*]]
-; CHECK:       a3:
-; CHECK-NEXT:    call void @assert_fail_1(i32 2)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont3:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %c1 = call i1 @foo()
   br i1 %c1, label %cont1, label %a1
 a1:
   call void @assert_fail_1(i32 0)
a3:
   unreachable
 cont3:
   ret void
 }
 
 define void @dont_phi_values(i32 %x, i32 %y) {
 ; CHECK-LABEL: @dont_phi_values(
 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[A1:%.*]]
-; CHECK:       a1:
-; CHECK-NEXT:    call void @assert_fail_1(i32 [[X:%.*]])
+; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[COMMON_UNREACHABLE:%.*]]
+; CHECK:       common.unreachable:
+; CHECK-NEXT:    [[Y_SINK:%.*]] = phi i32 [ [[X:%.*]], [[TMP0:%.*]] ], [ [[Y:%.*]], [[CONT1]] ]
+; CHECK-NEXT:    call void @assert_fail_1(i32 [[Y_SINK]])
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cont1:
 ; CHECK-NEXT:    [[C2:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[A2:%.*]]
-; CHECK:       a2:
-; CHECK-NEXT:    call void @assert_fail_1(i32 [[Y:%.*]])
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont2:
 ; CHECK-NEXT:    ret void
 ;
   %c1 = call i1 @foo()
   br i1 %c1, label %cont1, label %a1
 a1:
   call void @assert_fail_1(i32 %x)
   unreachable

 declare i1 @bar()
 
 define void @unmergeable_phis(i32 %v, i1 %c) {
 ; CHECK-LABEL: @unmergeable_phis(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[S1:%.*]], label [[S2:%.*]]
 ; CHECK:       s1:
 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C1]], label [[A1:%.*]], label [[A2:%.*]]
+; CHECK-NEXT:    br i1 [[C1]], label [[COMMON_UNREACHABLE:%.*]], label [[A2:%.*]]
 ; CHECK:       s2:
 ; CHECK-NEXT:    [[C2:%.*]] = call i1 @bar()
-; CHECK-NEXT:    br i1 [[C2]], label [[A1]], label [[A2]]
-; CHECK:       a1:
-; CHECK-NEXT:    [[L1:%.*]] = phi i32 [ 0, [[S1]] ], [ 1, [[S2]] ]
-; CHECK-NEXT:    call void @assert_fail_1(i32 [[L1]])
+; CHECK-NEXT:    br i1 [[C2]], label [[COMMON_UNREACHABLE]], label [[A2]]
+; CHECK:       common.unreachable:
+; CHECK-NEXT:    [[L2_SINK:%.*]] = phi i32 [ [[L2:%.*]], [[A2]] ], [ 0, [[S1]] ], [ 1, [[S2]] ]
+; CHECK-NEXT:    call void @assert_fail_1(i32 [[L2_SINK]])
 ; CHECK-NEXT:    unreachable
 ; CHECK:       a2:
-; CHECK-NEXT:    [[L2:%.*]] = phi i32 [ 2, [[S1]] ], [ 3, [[S2]] ]
-; CHECK-NEXT:    call void @assert_fail_1(i32 [[L2]])
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    [[L2]] = phi i32 [ 2, [[S1]] ], [ 3, [[S2]] ]
+; CHECK-NEXT:    br label [[COMMON_UNREACHABLE]]
 ;
 entry:
   br i1 %c, label %s1, label %s2
 s1:
   %c1 = call i1 @foo()
   br i1 %c1, label %a1, label %a2
 s2:
   %c2 = call i1 @bar()
   br i1 %c2, label %a1, label %a2
 a1:
   %l1 = phi i32 [ 0, %s1 ], [ 1, %s2 ]
   call void @assert_fail_1(i32 %l1)
   unreachable
 a2:
   %l2 = phi i32 [ 2, %s1 ], [ 3, %s2 ]
   call void @assert_fail_1(i32 %l2)
   unreachable
 }
 
 define void @tail_merge_switch(i32 %v) {
 ; CHECK-LABEL: @tail_merge_switch(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    switch i32 [[V:%.*]], label [[RET:%.*]] [
-; CHECK-NEXT:    i32 0, label [[A1:%.*]]
+; CHECK-NEXT:    i32 0, label [[COMMON_UNREACHABLE:%.*]]
 ; CHECK-NEXT:    i32 13, label [[A2:%.*]]
 ; CHECK-NEXT:    i32 42, label [[A3:%.*]]
 ; CHECK-NEXT:    ]
-; CHECK:       a1:
-; CHECK-NEXT:    call void @assert_fail_1(i32 0)
+; CHECK:       common.unreachable:
+; CHECK-NEXT:    [[DOTSINK:%.*]] = phi i32 [ 2, [[A3]] ], [ 1, [[A2]] ], [ 0, [[ENTRY:%.*]] ]
+; CHECK-NEXT:    call void @assert_fail_1(i32 [[DOTSINK]])
 ; CHECK-NEXT:    unreachable
 ; CHECK:       a2:
-; CHECK-NEXT:    call void @assert_fail_1(i32 1)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br label [[COMMON_UNREACHABLE]]
 ; CHECK:       a3:
-; CHECK-NEXT:    call void @assert_fail_1(i32 2)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br label [[COMMON_UNREACHABLE]]
 ; CHECK:       ret:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   switch i32 %v, label %ret [
   i32 0, label %a1
   i32 13, label %a2
   i32 42, label %a3
a3:
   unreachable
 ret:
   ret void
 }
 
 define void @need_to_add_bb2_preds(i1 %c1) {
 ; CHECK-LABEL: @need_to_add_bb2_preds(
 ; CHECK-NEXT:  bb1:
-; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB2:%.*]], label [[A1:%.*]]
+; CHECK-NEXT:    br i1 [[C1:%.*]], label [[BB2:%.*]], label [[COMMON_UNREACHABLE:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[C2:%.*]] = call i1 @bar()
-; CHECK-NEXT:    br i1 [[C2]], label [[A2:%.*]], label [[A3:%.*]]
-; CHECK:       a1:
-; CHECK-NEXT:    call void @assert_fail_1(i32 0)
-; CHECK-NEXT:    unreachable
-; CHECK:       a2:
-; CHECK-NEXT:    call void @assert_fail_1(i32 1)
-; CHECK-NEXT:    unreachable
-; CHECK:       a3:
-; CHECK-NEXT:    call void @assert_fail_1(i32 2)
+; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = select i1 [[C2]], i32 1, i32 2
+; CHECK-NEXT:    br label [[COMMON_UNREACHABLE]]
+; CHECK:       common.unreachable:
+; CHECK-NEXT:    [[DOTSINK:%.*]] = phi i32 [ 0, [[BB1:%.*]] ], [ [[SPEC_SELECT]], [[BB2]] ]
+; CHECK-NEXT:    call void @assert_fail_1(i32 [[DOTSINK]])
 ; CHECK-NEXT:    unreachable
 ;
 bb1:
   br i1 %c1, label %bb2, label %a1
 bb2:
   %c2 = call i1 @bar()
   br i1 %c2, label %a2, label %a3
 
 a1:
   call void @assert_fail_1(i32 0)
   unreachable
 a2:
   call void @assert_fail_1(i32 1)
   unreachable
 a3:
   call void @assert_fail_1(i32 2)
   unreachable
 }
 
 define void @phi_in_bb2() {
 ; CHECK-LABEL: @phi_in_bb2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[A1:%.*]]
-; CHECK:       a1:
-; CHECK-NEXT:    call void @assert_fail_1(i32 0)
+; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[COMMON_UNREACHABLE:%.*]]
+; CHECK:       common.unreachable:
+; CHECK-NEXT:    [[P2_SINK:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 1, [[CONT1]] ], [ 2, [[CONT2:%.*]] ]
+; CHECK-NEXT:    call void @assert_fail_1(i32 [[P2_SINK]])
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cont1:
 ; CHECK-NEXT:    [[C2:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[A2:%.*]]
-; CHECK:       a2:
-; CHECK-NEXT:    [[P2:%.*]] = phi i32 [ 1, [[CONT1]] ], [ 2, [[CONT2]] ]
-; CHECK-NEXT:    call void @assert_fail_1(i32 [[P2]])
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[C2]], label [[CONT2]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont2:
 ; CHECK-NEXT:    [[C3:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[A2]]
+; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont3:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %c1 = call i1 @foo()
   br i1 %c1, label %cont1, label %a1
 a1:
   call void @assert_fail_1(i32 0)

 ; CHECK:       if.then:
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[X]])
 ; CHECK-NEXT:    store i32 0, ptr [[X]], align 4
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[C2:%.*]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN1:%.*]]
 ; CHECK:       if.then1:
 ; CHECK-NEXT:    call void @escape_i32_ptr(ptr nonnull [[X]])
 ; CHECK-NEXT:    br label [[IF_END]]
-; CHECK:       if.end:
-; CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X]])
+; CHECK:       common.unreachable:
 ; CHECK-NEXT:    call void @abort()
 ; CHECK-NEXT:    unreachable
+; CHECK:       if.end:
+; CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[X]])
+; CHECK-NEXT:    br label [[COMMON_UNREACHABLE:%.*]]
 ; CHECK:       if.then3:
 ; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr nonnull [[Y]])
 ; CHECK-NEXT:    store i32 0, ptr [[Y]], align 4
 ; CHECK-NEXT:    [[TOBOOL5:%.*]] = icmp eq i32 [[C2]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL5]], label [[IF_END7:%.*]], label [[IF_THEN6:%.*]]
 ; CHECK:       if.then6:
 ; CHECK-NEXT:    call void @escape_i32_ptr(ptr nonnull [[Y]])
 ; CHECK-NEXT:    br label [[IF_END7]]
 ; CHECK:       if.end7:
 ; CHECK-NEXT:    call void @llvm.lifetime.end.p0(i64 4, ptr nonnull [[Y]])
-; CHECK-NEXT:    call void @abort()
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br label [[COMMON_UNREACHABLE]]
 ; CHECK:       if.end9:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %x = alloca i32, align 4
   %y = alloca i32, align 4
   switch i32 %c1, label %if.end9 [
   i32 13, label %if.then

 ; Dead phis in the block need to be handled.
 
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 
 define void @dead_phi() {
 ; CHECK-LABEL: @dead_phi(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C1:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[A1:%.*]]
-; CHECK:       a1:
-; CHECK-NEXT:    [[DEAD:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 1, [[CONT1]] ]
+; CHECK-NEXT:    br i1 [[C1]], label [[CONT1:%.*]], label [[COMMON_UNREACHABLE:%.*]]
+; CHECK:       common.unreachable:
 ; CHECK-NEXT:    call void @assert_fail_1(i32 0)
 ; CHECK-NEXT:    unreachable
 ; CHECK:       cont1:
 ; CHECK-NEXT:    [[C2:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[A1]]
+; CHECK-NEXT:    br i1 [[C2]], label [[CONT2:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont2:
 ; CHECK-NEXT:    [[C3:%.*]] = call i1 @foo()
-; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[A3:%.*]]
-; CHECK:       a3:
-; CHECK-NEXT:    call void @assert_fail_1(i32 0)
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br i1 [[C3]], label [[CONT3:%.*]], label [[COMMON_UNREACHABLE]]
 ; CHECK:       cont3:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %c1 = call i1 @foo()
   br i1 %c1, label %cont1, label %a1
 a1:
   %dead = phi i32 [ 0, %entry ], [ 1, %cont1 ]
cont3:
   ret void
 }
 
 define void @strip_dbg_value(i32 %c) {
 ; CHECK-LABEL: @strip_dbg_value(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[C:%.*]], metadata [[META5:![0-9]+]], metadata !DIExpression()), !dbg [[DBG7:![0-9]+]]
 ; CHECK-NEXT:    switch i32 [[C]], label [[SW_EPILOG:%.*]] [
-; CHECK-NEXT:    i32 13, label [[SW_BB:%.*]]
-; CHECK-NEXT:    i32 42, label [[SW_BB1:%.*]]
+; CHECK-NEXT:    i32 13, label [[COMMON_UNREACHABLE:%.*]]
+; CHECK-NEXT:    i32 42, label [[COMMON_UNREACHABLE]]
 ; CHECK-NEXT:    ]
-; CHECK:       sw.bb:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 55, metadata [[META5]], metadata !DIExpression()), !dbg [[DBG7]]
-; CHECK-NEXT:    tail call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       sw.bb1:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 67, metadata [[META5]], metadata !DIExpression()), !dbg [[DBG7]]
+; CHECK:       common.unreachable:
 ; CHECK-NEXT:    tail call void @abort()
 ; CHECK-NEXT:    unreachable
 ; CHECK:       sw.epilog:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   call void @llvm.dbg.value(metadata i32 %c, i64 0, metadata !12, metadata !13), !dbg !14
   switch i32 %c, label %sw.epilog [
sw.epilog:                                        ; preds = %entry
   ret void
 }
 
 define void @dead_phi_and_dbg(i32 %c) {
 ; CHECK-LABEL: @dead_phi_and_dbg(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[C:%.*]], metadata [[META5]], metadata !DIExpression()), !dbg [[DBG7]]
 ; CHECK-NEXT:    switch i32 [[C]], label [[SW_EPILOG:%.*]] [
-; CHECK-NEXT:    i32 13, label [[SW_BB:%.*]]
-; CHECK-NEXT:    i32 42, label [[SW_BB1:%.*]]
-; CHECK-NEXT:    i32 53, label [[SW_BB2:%.*]]
+; CHECK-NEXT:    i32 13, label [[COMMON_UNREACHABLE:%.*]]
+; CHECK-NEXT:    i32 42, label [[COMMON_UNREACHABLE]]
+; CHECK-NEXT:    i32 53, label [[COMMON_UNREACHABLE]]
 ; CHECK-NEXT:    ]
-; CHECK:       sw.bb:
-; CHECK-NEXT:    [[C_1:%.*]] = phi i32 [ 55, [[ENTRY:%.*]] ], [ 67, [[SW_BB1]] ]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 [[C_1]], metadata [[META5]], metadata !DIExpression()), !dbg [[DBG7]]
-; CHECK-NEXT:    tail call void @abort()
-; CHECK-NEXT:    unreachable
-; CHECK:       sw.bb1:
-; CHECK-NEXT:    br label [[SW_BB]]
-; CHECK:       sw.bb2:
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32 84, metadata [[META5]], metadata !DIExpression()), !dbg [[DBG7]]
+; CHECK:       common.unreachable:
 ; CHECK-NEXT:    tail call void @abort()
 ; CHECK-NEXT:    unreachable
 ; CHECK:       sw.epilog:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   call void @llvm.dbg.value(metadata i32 %c, i64 0, metadata !12, metadata !13), !dbg !14
   switch i32 %c, label %sw.epilog [