[WebAssembly] Make LBB markers not affected by test order

[aheejin]

Summary

This way we can change the order of tests or delete some of them without
affecting tests for other functions.

[aheejin]

Ping

[aheejin]

Ping. I guess I can just commit this, because it's simple anyway

[tlively]

Looks good!

test/CodeGen/WebAssembly/cfg-stackify.ll

 ; Test that loops are made contiguous, even in the presence of split backedges.
 
 ; CHECK-LABEL: test0:
 ; CHECK: loop
 ; CHECK-NEXT: block
 ; CHECK:      i32.lt_s
 ; CHECK-NEXT: br_if
 ; CHECK-NEXT: return
-; CHECK-NEXT: .LBB0_3:
+; CHECK-NEXT: .LBB{{[0-9]+}}_3:
 ; CHECK-NEXT: end_block
 ; CHECK-NEXT: i32.const
 ; CHECK-NEXT: i32.add
 ; CHECK-NEXT: call
 ; CHECK-NEXT: br
-; CHECK-NEXT: .LBB0_4:
+; CHECK-NEXT: .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT: end_loop
 define void @test0(i32 %n) {
 entry:
   br label %header
 
 header:
   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
   %i.next = add i32 %i, 1

 ; Same as test0, but the branch condition is reversed.
 
 ; CHECK-LABEL: test1:
 ; CHECK: loop
 ; CHECK-NEXT: block
 ; CHECK:      i32.lt_s
 ; CHECK-NEXT: br_if
 ; CHECK-NEXT: return
-; CHECK-NEXT: .LBB1_3:
+; CHECK-NEXT: .LBB{{[0-9]+}}_3:
 ; CHECK-NEXT: end_block
 ; CHECK-NEXT: i32.const
 ; CHECK-NEXT: i32.add
 ; CHECK-NEXT: call
 ; CHECK-NEXT: br
-; CHECK-NEXT: .LBB1_4:
+; CHECK-NEXT: .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT: end_loop
 define void @test1(i32 %n) {
 entry:
   br label %header
 
 header:
   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
   %i.next = add i32 %i, 1

 }
 
 ; Test that a simple loop is handled as expected.
 
 ; CHECK-LABEL: test2:
 ; CHECK-NOT: local
 ; CHECK: block   {{$}}
 ; CHECK: br_if 0, {{[^,]+}}{{$}}
-; CHECK: .LBB2_{{[0-9]+}}:
+; CHECK: .LBB{{[0-9]+}}_{{[0-9]+}}:
 ; CHECK: loop
 ; CHECK: br_if 0, $pop{{[0-9]+}}{{$}}
-; CHECK: .LBB2_{{[0-9]+}}:
+; CHECK: .LBB{{[0-9]+}}_{{[0-9]+}}:
 ; CHECK: end_loop
 ; CHECK: end_block
 ; CHECK: return{{$}}
 define void @test2(double* nocapture %p, i32 %n) {
 entry:
   %cmp.4 = icmp sgt i32 %n, 0
   br i1 %cmp.4, label %for.body.preheader, label %for.end
 
for.end:
   ret void
 }
 
 ; CHECK-LABEL: doublediamond:
 ; CHECK: block   {{$}}
 ; CHECK-NEXT: block   {{$}}
 ; CHECK: br_if 0, ${{[^,]+}}{{$}}
 ; CHECK: br 1{{$}}
-; CHECK: .LBB3_2:
+; CHECK: .LBB{{[0-9]+}}_2:
 ; CHECK-NEXT: end_block{{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_if 0, ${{[^,]+}}{{$}}
 ; CHECK: br 1{{$}}
-; CHECK: .LBB3_4:
+; CHECK: .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT: end_block{{$}}
-; CHECK: .LBB3_5:
+; CHECK: .LBB{{[0-9]+}}_5:
 ; CHECK-NEXT: end_block{{$}}
 ; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}}
 ; CHECK-NEXT: return $pop{{[0-9]+}}{{$}}
 define i32 @doublediamond(i32 %a, i32 %b, i32* %p) {
 entry:
   %c = icmp eq i32 %a, 0
   %d = icmp eq i32 %b, 0
   store volatile i32 0, i32* %p

 exit:
   store volatile i32 5, i32* %p
   ret i32 0
 }
 
 ; CHECK-LABEL: triangle:
 ; CHECK: block   {{$}}
 ; CHECK: br_if 0, $1{{$}}
-; CHECK: .LBB4_2:
+; CHECK: .LBB{{[0-9]+}}_2:
 ; CHECK: return
 define i32 @triangle(i32* %p, i32 %a) {
 entry:
   %c = icmp eq i32 %a, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %exit
 true:
   store volatile i32 1, i32* %p
   br label %exit
 exit:
   store volatile i32 2, i32* %p
   ret i32 0
 }
 
 ; CHECK-LABEL: diamond:
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_if 0, $1{{$}}
 ; CHECK: br 1{{$}}
-; CHECK: .LBB5_2:
-; CHECK: .LBB5_3:
+; CHECK: .LBB{{[0-9]+}}_2:
+; CHECK: .LBB{{[0-9]+}}_3:
 ; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}}
 ; CHECK-NEXT: return $pop{{[0-9]+}}{{$}}
 define i32 @diamond(i32* %p, i32 %a) {
 entry:
   %c = icmp eq i32 %a, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %false
 true:

 define i32 @single_block(i32* %p) {
 entry:
   store volatile i32 0, i32* %p
   ret i32 0
 }
 
 ; CHECK-LABEL: minimal_loop:
 ; CHECK-NOT: br
-; CHECK: .LBB7_1:
+; CHECK: .LBB{{[0-9]+}}_1:
 ; CHECK: loop i32
 ; CHECK: i32.store 0($0), $pop{{[0-9]+}}{{$}}
 ; CHECK: br 0{{$}}
-; CHECK: .LBB7_2:
+; CHECK: .LBB{{[0-9]+}}_2:
 define i32 @minimal_loop(i32* %p) {
 entry:
   store volatile i32 0, i32* %p
   br label %loop
 loop:
   store volatile i32 1, i32* %p
   br label %loop
 }
 
 ; CHECK-LABEL: simple_loop:
 ; CHECK-NOT: br
-; CHECK: .LBB8_1:
+; CHECK: .LBB{{[0-9]+}}_1:
 ; CHECK: loop    {{$}}
 ; CHECK: br_if 0, $pop{{[0-9]+}}{{$}}
 ; CHECK-NEXT: end_loop{{$}}
 ; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}}
 ; CHECK-NEXT: return $pop{{[0-9]+}}{{$}}
 define i32 @simple_loop(i32* %p, i32 %a) {
 entry:
   %c = icmp eq i32 %a, 0
   store volatile i32 0, i32* %p
   br label %loop
 loop:
   store volatile i32 1, i32* %p
   br i1 %c, label %loop, label %exit
 exit:
   store volatile i32 2, i32* %p
   ret i32 0
 }
 
 ; CHECK-LABEL: doubletriangle:
 ; CHECK: block   {{$}}
 ; CHECK: br_if 0, $0{{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_if 0, $1{{$}}
-; CHECK: .LBB9_3:
-; CHECK: .LBB9_4:
+; CHECK: .LBB{{[0-9]+}}_3:
+; CHECK: .LBB{{[0-9]+}}_4:
 ; CHECK: return
 define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) {
 entry:
   %c = icmp eq i32 %a, 0
   %d = icmp eq i32 %b, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %exit
 true:
exit:
   ret i32 0
 }
 
 ; CHECK-LABEL: ifelse_earlyexits:
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_if 0, $0{{$}}
 ; CHECK: br 1{{$}}
-; CHECK: .LBB10_2:
+; CHECK: .LBB{{[0-9]+}}_2:
 ; CHECK: br_if 0, $1{{$}}
-; CHECK: .LBB10_4:
+; CHECK: .LBB{{[0-9]+}}_4:
 ; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}}
 ; CHECK-NEXT: return $pop{{[0-9]+}}{{$}}
 define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) {
 entry:
   %c = icmp eq i32 %a, 0
   %d = icmp eq i32 %b, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %false
 true:
   store volatile i32 1, i32* %p
   br label %exit
 false:
   store volatile i32 2, i32* %p
   br i1 %d, label %ft, label %exit
 ft:
   store volatile i32 3, i32* %p
   br label %exit
 exit:
   store volatile i32 4, i32* %p
   ret i32 0
 }
 
 ; CHECK-LABEL: doublediamond_in_a_loop:
-; CHECK: .LBB11_1:
+; CHECK: .LBB{{[0-9]+}}_1:
 ; CHECK: loop i32{{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_if           0, $0{{$}}
 ; CHECK: br              1{{$}}
-; CHECK: .LBB11_3:
+; CHECK: .LBB{{[0-9]+}}_3:
 ; CHECK: end_block{{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_if           0, $1{{$}}
 ; CHECK: br              1{{$}}
-; CHECK: .LBB11_5:
+; CHECK: .LBB{{[0-9]+}}_5:
 ; CHECK: br              0{{$}}
-; CHECK: .LBB11_6:
+; CHECK: .LBB{{[0-9]+}}_6:
 ; CHECK-NEXT: end_loop{{$}}
 define i32 @doublediamond_in_a_loop(i32 %a, i32 %b, i32* %p) {
 entry:
   br label %header
 header:
   %c = icmp eq i32 %a, 0
   %d = icmp eq i32 %b, 0
   store volatile i32 0, i32* %p

 
 ; CHECK-LABEL: test4:
 ; CHECK-NEXT: .functype test4 (i32) -> (){{$}}
 ; CHECK:      block   {{$}}
 ; CHECK-NEXT: block   {{$}}
 ; CHECK:      br_if       0, $pop{{[0-9]+}}{{$}}
 ; CHECK:      br_if       1, $pop{{[0-9]+}}{{$}}
 ; CHECK:      br          1{{$}}
-; CHECK-NEXT: .LBB13_3:
+; CHECK-NEXT: .LBB{{[0-9]+}}_3:
 ; CHECK-NEXT: end_block{{$}}
 ; CHECK-NEXT: block   {{$}}
 ; CHECK:      br_if 0, $pop{{[0-9]+}}{{$}}
 ; CHECK:      br_if 1, $pop{{[0-9]+}}{{$}}
-; CHECK-NEXT: .LBB13_5:
+; CHECK-NEXT: .LBB{{[0-9]+}}_5:
 ; CHECK-NEXT: end_block{{$}}
 ; CHECK-NEXT: return{{$}}
-; CHECK-NEXT: .LBB13_6:
+; CHECK-NEXT: .LBB{{[0-9]+}}_6:
 ; CHECK-NEXT: end_block{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @test4(i32 %t) {
 entry:
   switch i32 %t, label %default [
     i32 0, label %bb2
     i32 2, label %bb2
     i32 4, label %bb1

 default:
   ret void
 }
 
 ; Test a case where the BLOCK needs to be placed before the LOOP in the
 ; same basic block.
 
 ; CHECK-LABEL: test5:
-; CHECK:       .LBB14_1:
+; CHECK:       .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK:       br_if 1, {{[^,]+}}{{$}}
 ; CHECK:       br_if 0, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  end_loop{{$}}
 ; CHECK:       return{{$}}
-; CHECK-NEXT:  .LBB14_4:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_4:
 ; CHECK:       return{{$}}
 define void @test5(i1 %p, i1 %q) {
 entry:
   br label %header
 
 header:
   store volatile i32 0, i32* null
   br i1 %p, label %more, label %alt
return:
   ret void
 }
 
 ; Test an interesting case of a loop with multiple exits, which
 ; aren't to layout successors of the loop, and one of which is to a successors
 ; which has another predecessor.
 
 ; CHECK-LABEL: test6:
-; CHECK:       .LBB15_1:
+; CHECK:       .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if 2, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if 1, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if 0, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  end_loop{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       return{{$}}
-; CHECK-NEXT:  .LBB15_5:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_5:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
-; CHECK:       .LBB15_6:
+; CHECK:       .LBB{{[0-9]+}}_6:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       return{{$}}
 define void @test6(i1 %p, i1 %q) {
 entry:
   br label %header
 
 header:
second:
   store volatile i32 4, i32* null
   ret void
 }
 
 ; Test a case where there are multiple backedges and multiple loop exits
 ; that end in unreachable.
 
 ; CHECK-LABEL: test7:
-; CHECK:       .LBB16_1:
+; CHECK:       .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       block   {{$}}
 ; CHECK:       br_if 0, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if 1, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       unreachable
-; CHECK-NEXT:  .LBB16_4:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if 0, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  end_loop{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       unreachable
 define void @test7(i1 %tobool2, i1 %tobool9) {
 entry:

 u1:
   store volatile i32 5, i32* null
   unreachable
 }
 
 ; Test an interesting case using nested loops and switches.
 
 ; CHECK-LABEL: test8:
-; CHECK:       .LBB17_1:
+; CHECK:       .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT:  loop i32{{$}}
 ; CHECK-NEXT:  i32.const $push{{[^,]+}}, 0{{$}}
 ; CHECK-NEXT:  br_if    0, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  br       0{{$}}
-; CHECK-NEXT:  .LBB17_2:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_2:
 ; CHECK-NEXT:  end_loop{{$}}
 define i32 @test8() {
 bb:
   br label %bb1
 
 bb1:
   br i1 undef, label %bb2, label %bb3
 
 bb2:
   switch i8 undef, label %bb1 [
     i8 44, label %bb2
   ]
 
 bb3:
   switch i8 undef, label %bb1 [
     i8 44, label %bb2
   ]
 }
 
 ; Test an interesting case using nested loops that share a bottom block.
 
 ; CHECK-LABEL: test9:
-; CHECK:       .LBB18_1:
+; CHECK:       .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if     1, {{[^,]+}}{{$}}
-; CHECK-NEXT:  .LBB18_2:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_2:
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       block   {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if     0, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if     2, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  br        1{{$}}
-; CHECK-NEXT:  .LBB18_4:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if     1, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  br        0{{$}}
-; CHECK-NEXT:  .LBB18_5:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_5:
 ; CHECK-NOT:   block
 ; CHECK:       end_block
 ; CHECK-NOT:   block
 ; CHECK:       return{{$}}
 declare i1 @a()
 define void @test9() {
 entry:
   store volatile i32 0, i32* null
end:
   store volatile i32 5, i32* null
   ret void
 }
 
 ; Test an interesting case involving nested loops sharing a loop bottom,
 ; and loop exits to a block with unreachable.
 
 ; CHECK-LABEL: test10:
-; CHECK:       .LBB19_1:
+; CHECK:       .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if    0, {{[^,]+}}{{$}}
-; CHECK:       .LBB19_3:
+; CHECK:       .LBB{{[0-9]+}}_3:
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
-; CHECK:       .LBB19_4:
+; CHECK:       .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if    0, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  end_loop{{$}}
 ; CHECK:       br_if    1, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if    0, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  end_loop{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if    1, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  return{{$}}
-; CHECK-NEXT:  .LBB19_9:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_9:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br       0{{$}}
-; CHECK-NEXT:  .LBB19_10:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_10:
 define void @test10() {
 bb0:
   br label %bb1
 
 bb1:
   %tmp = phi i32 [ 2, %bb0 ], [ 3, %bb3 ]
   %tmp3 = phi i32 [ undef, %bb0 ], [ %tmp11, %bb3 ]
   %tmp4 = icmp eq i32 %tmp3, 0

 ; CHECK-NEXT:  block   {{$}}
 ; CHECK:       br_if        0, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       block   {{$}}
 ; CHECK-NEXT:  i32.const
 ; CHECK-NEXT:  br_if        0, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if        2, {{[^,]+}}{{$}}
-; CHECK-NEXT:  .LBB20_3:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_3:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       return{{$}}
-; CHECK-NEXT:  .LBB20_4:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if        1, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if        2, {{[^,]+}}{{$}}
-; CHECK-NEXT:  .LBB20_6:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_6:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       return{{$}}
-; CHECK-NEXT:  .LBB20_7:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_7:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       return{{$}}
-; CHECK-NEXT:  .LBB20_8:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_8:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       return{{$}}
 define void @test11() {
 bb0:
   store volatile i32 0, i32* null
   br i1 undef, label %bb1, label %bb4
 bb1:
bb7:
   store volatile i32 7, i32* null
   ret void
 bb8:
   store volatile i32 8, i32* null
   ret void
 }
 
 ; CHECK-LABEL: test12:
-; CHECK:       .LBB21_1:
+; CHECK:       .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK-NEXT:  loop    {{$}}
 ; CHECK-NOT:   block
 ; CHECK:       block   {{$}}
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK:       br_if       0, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if       1, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if       1, {{[^,]+}}{{$}}
 ; CHECK-NEXT:  br          3{{$}}
-; CHECK-NEXT:  .LBB21_4:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if       0, {{[^,]+}}{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br_if       2, {{[^,]+}}{{$}}
-; CHECK-NEXT:  .LBB21_6:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_6:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NOT:   block
 ; CHECK:       br          0{{$}}
-; CHECK-NEXT:  .LBB21_7:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_7:
 ; CHECK-NEXT:  end_loop{{$}}
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NEXT:  return{{$}}
 define void @test12(i8* %arg) {
 bb:
   br label %bb1
 
 bb1:

 ; optnone to disable optimizations to test this case.
 
 ; CHECK-LABEL: test13:
 ; CHECK:       block   {{$}}
 ; CHECK-NEXT:  block   {{$}}
 ; CHECK:       br_if 0, $pop0{{$}}
 ; CHECK:       block   {{$}}
 ; CHECK:       br_if 0, $pop3{{$}}
-; CHECK:       .LBB22_3:
+; CHECK:       .LBB{{[0-9]+}}_3:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK:       br_if 1, $pop{{[0-9]+}}{{$}}
 ; CHECK-NEXT:  br 1{{$}}
-; CHECK-NEXT:  .LBB22_4:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NEXT:  return{{$}}
-; CHECK-NEXT:  .LBB22_5:
+; CHECK-NEXT:  .LBB{{[0-9]+}}_5:
 ; CHECK-NEXT:  end_block{{$}}
 ; CHECK-NEXT:  unreachable{{$}}
 define void @test13() noinline optnone {
 bb:
   br i1 undef, label %bb5, label %bb2
 bb1:
   unreachable
 bb2:
   br i1 undef, label %bb3, label %bb4
 bb3:
   br label %bb4
 bb4:
   %tmp = phi i1 [ false, %bb2 ], [ false, %bb3 ]
   br i1 %tmp, label %bb1, label %bb1
 bb5:
   ret void
 }
 
 ; Test a case with a single-block loop that has another loop
 ; as a successor. The end_loop for the first loop should go
 ; before the loop for the second.
 
 ; CHECK-LABEL: test14:
-; CHECK:      .LBB23_1:{{$}}
+; CHECK:      .LBB{{[0-9]+}}_1:{{$}}
 ; CHECK-NEXT:     loop    {{$}}
 ; CHECK-NEXT:     i32.const   $push0=, 0{{$}}
 ; CHECK-NEXT:     br_if       0, $pop0{{$}}
 ; CHECK-NEXT:     end_loop{{$}}
-; CHECK-NEXT: .LBB23_3:{{$}}
+; CHECK-NEXT: .LBB{{[0-9]+}}_3:{{$}}
 ; CHECK-NEXT:     loop    {{$}}
 ; CHECK-NEXT:     i32.const   $push1=, 0{{$}}
 ; CHECK-NEXT:     br_if       0, $pop1{{$}}
 ; CHECK-NEXT:     end_loop{{$}}
 ; CHECK-NEXT:     return{{$}}
 define void @test14() {
 bb:
   br label %bb1

 
 ; Test that a block boundary which ends one block, begins another block, and
 ; also begins a loop, has the markers placed in the correct order.
 
 ; CHECK-LABEL: test15:
 ; CHECK:        block
 ; CHECK-NEXT:   block
 ; CHECK:        br_if       0, $pop{{.*}}{{$}}
-; CHECK:        .LBB24_2:
+; CHECK:        .LBB{{[0-9]+}}_2:
 ; CHECK-NEXT:   block   {{$}}
 ; CHECK-NEXT:   block   {{$}}
 ; CHECK-NEXT:   loop    {{$}}
 ; CHECK:        br_if       1, $pop{{.*}}{{$}}
 ; CHECK:        br_if       0, ${{.*}}{{$}}
 ; CHECK-NEXT:   br          2{{$}}
-; CHECK-NEXT:   .LBB24_4:
+; CHECK-NEXT:   .LBB{{[0-9]+}}_4:
 ; CHECK-NEXT:   end_loop{{$}}
-; CHECK:        .LBB24_5:
+; CHECK:        .LBB{{[0-9]+}}_5:
 ; CHECK-NEXT:   end_block{{$}}
 ; CHECK:        br_if       1, $pop{{.*}}{{$}}
 ; CHECK:        return{{$}}
-; CHECK:        .LBB24_7:
+; CHECK:        .LBB{{[0-9]+}}_7:
 ; CHECK-NEXT:   end_block{{$}}
-; CHECK:        .LBB24_8:
+; CHECK:        .LBB{{[0-9]+}}_8:
 ; CHECK-NEXT:   end_block{{$}}
 ; CHECK-NEXT:   return{{$}}
 %0 = type { i8, i32 }
 declare void @test15_callee0()
 declare void @test15_callee1()
 define void @test15() {
 bb:
   %tmp1 = icmp eq i8 1, 0

test/CodeGen/WebAssembly/phi.ll

 done:
   %s = phi i32 [ %a, %true ], [ %p, %entry ]
   ret i32 %s
 }
 
 ; Swap phis.
 
 ; CHECK-LABEL: test1:
-; CHECK: .LBB1_1:
+; CHECK: .LBB{{[0-9]+}}_1:
 ; CHECK: local.copy $[[NUM0:[0-9]+]]=, $[[NUM1:[0-9]+]]{{$}}
 ; CHECK: local.copy $[[NUM1]]=, $[[NUM2:[0-9]+]]{{$}}
 ; CHECK: local.copy $[[NUM2]]=, $[[NUM0]]{{$}}
 define i32 @test1(i32 %n) {
 entry:
   br label %loop
 
 loop:

test/CodeGen/WebAssembly/reg-stackify.ll

 ; CHECK-NEXT: i32.lt_s    $push[[L4:[0-9]+]]=, $3, $pop[[L11]]{{$}}
 ; CHECK-NEXT: i32.xor     $push[[L6:[0-9]+]]=, $pop[[L3]], $pop[[L4]]{{$}}
 ; CHECK-NEXT: i32.xor     $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
 ; CHECK-NEXT: i32.const   $push10=, 1{{$}}
 ; CHECK-NEXT: i32.ne      $push8=, $pop7, $pop10{{$}}
 ; CHECK-NEXT: br_if       0, $pop8{{$}}
 ; CHECK-NEXT: i32.const   $push9=, 0{{$}}
 ; CHECK-NEXT: return      $pop9{{$}}
-; CHECK-NEXT: .LBB7_2:
+; CHECK-NEXT: .LBB{{[0-9]+}}_2:
 ; CHECK-NEXT: end_block{{$}}
 ; CHECK-NEXT: i32.const   $push14=, 1{{$}}
 ; CHECK-NEXT: return      $pop14{{$}}
 ; NOREGS-LABEL: stack_uses:
 ; NOREGS: .functype stack_uses (i32, i32, i32, i32) -> (i32){{$}}
 ; NOREGS-NEXT: block {{$}}
 ; NOREGS-NEXT: local.get 0{{$}}
 ; NOREGS-NEXT: i32.const   1{{$}}

 ; NOREGS-NEXT: i32.lt_s
 ; NOREGS-NEXT: i32.xor {{$}}
 ; NOREGS-NEXT: i32.xor {{$}}
 ; NOREGS-NEXT: i32.const   1{{$}}
 ; NOREGS-NEXT: i32.ne {{$}}
 ; NOREGS-NEXT: br_if       0{{$}}
 ; NOREGS-NEXT: i32.const   0{{$}}
 ; NOREGS-NEXT: return{{$}}
-; NOREGS-NEXT: .LBB7_2:
+; NOREGS-NEXT: .LBB{{[0-9]+}}_2:
 ; NOREGS-NEXT: end_block{{$}}
 ; NOREGS-NEXT: i32.const   1{{$}}
 ; NOREGS-NEXT: return{{$}}
 define i32 @stack_uses(i32 %x, i32 %y, i32 %z, i32 %w) {
 entry:
   %c = icmp sle i32 %x, 0
   %d = icmp sle i32 %y, 1
   %e = icmp sle i32 %z, 0

 ; CHECK-NEXT: block   {{$}}
 ; CHECK-NEXT: i32.load    $push[[NUM0:[0-9]+]]=, 0($2){{$}}
 ; CHECK-NEXT: local.tee   $push[[NUM1:[0-9]+]]=, $3=, $pop[[NUM0]]{{$}}
 ; CHECK-NEXT: i32.ge_u    $push[[NUM2:[0-9]+]]=, $pop[[NUM1]], $1{{$}}
 ; CHECK-NEXT: br_if       0, $pop[[NUM2]]{{$}}
 ; CHECK-NEXT: i32.lt_u    $push[[NUM3:[0-9]+]]=, $3, $0{{$}}
 ; CHECK-NEXT: br_if       0, $pop[[NUM3]]{{$}}
 ; CHECK-NEXT: i32.store   0($2), $3{{$}}
-; CHECK-NEXT: .LBB8_3:
+; CHECK-NEXT: .LBB{{[0-9]+}}_3:
 ; CHECK-NEXT: end_block{{$}}
 ; CHECK-NEXT: return{{$}}
 ; NOREGS-LABEL: multiple_uses:
 ; NOREGS: .functype multiple_uses (i32, i32, i32) -> (){{$}}
 ; NOREGS: .local i32{{$}}
 ; NOREGS-NEXT: block {{$}}
 ; NOREGS-NEXT: local.get   2{{$}}
 ; NOREGS-NEXT: i32.load    0{{$}}
 ; NOREGS-NEXT: local.tee   3{{$}}
 ; NOREGS-NEXT: local.get   1{{$}}
 ; NOREGS-NEXT: i32.ge_u
 ; NOREGS-NEXT: br_if       0{{$}}
 ; NOREGS-NEXT: local.get   3{{$}}
 ; NOREGS-NEXT: local.get   0{{$}}
 ; NOREGS-NEXT: i32.lt_u
 ; NOREGS-NEXT: br_if       0{{$}}
 ; NOREGS-NEXT: local.get   2{{$}}
 ; NOREGS-NEXT: local.get   3{{$}}
 ; NOREGS-NEXT: i32.store   0{{$}}
-; NOREGS-NEXT: .LBB8_3:
+; NOREGS-NEXT: .LBB{{[0-9]+}}_3:
 ; NOREGS-NEXT: end_block{{$}}
 ; NOREGS-NEXT: return{{$}}
 define void @multiple_uses(i32* %arg0, i32* %arg1, i32* %arg2) nounwind {
 bb:
   br label %loop
 
 loop:
   %tmp7 = load i32, i32* %arg2

test/CodeGen/WebAssembly/switch.ll

 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_table {{[^,]+}}, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4, 5, 0{{$}}
-; CHECK: .LBB0_2:
+; CHECK: .LBB{{[0-9]+}}_2:
 ; CHECK:   call foo0{{$}}
-; CHECK: .LBB0_3:
+; CHECK: .LBB{{[0-9]+}}_3:
 ; CHECK:   call foo1{{$}}
-; CHECK: .LBB0_4:
+; CHECK: .LBB{{[0-9]+}}_4:
 ; CHECK:   call foo2{{$}}
-; CHECK: .LBB0_5:
+; CHECK: .LBB{{[0-9]+}}_5:
 ; CHECK:   call foo3{{$}}
-; CHECK: .LBB0_6:
+; CHECK: .LBB{{[0-9]+}}_6:
 ; CHECK:   call foo4{{$}}
-; CHECK: .LBB0_7:
+; CHECK: .LBB{{[0-9]+}}_7:
 ; CHECK:   call foo5{{$}}
-; CHECK: .LBB0_8:
+; CHECK: .LBB{{[0-9]+}}_8:
 ; CHECK:   return{{$}}
 define void @bar32(i32 %n) {
 entry:
   switch i32 %n, label %sw.epilog [
     i32 0, label %sw.bb
     i32 1, label %sw.bb
     i32 2, label %sw.bb
     i32 3, label %sw.bb

 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: block   {{$}}
 ; CHECK: br_table {{[^,]+}}, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4, 5, 0{{$}}
-; CHECK: .LBB1_2:
+; CHECK: .LBB{{[0-9]+}}_2:
 ; CHECK:   call foo0{{$}}
-; CHECK: .LBB1_3:
+; CHECK: .LBB{{[0-9]+}}_3:
 ; CHECK:   call foo1{{$}}
-; CHECK: .LBB1_4:
+; CHECK: .LBB{{[0-9]+}}_4:
 ; CHECK:   call foo2{{$}}
-; CHECK: .LBB1_5:
+; CHECK: .LBB{{[0-9]+}}_5:
 ; CHECK:   call foo3{{$}}
-; CHECK: .LBB1_6:
+; CHECK: .LBB{{[0-9]+}}_6:
 ; CHECK:   call foo4{{$}}
-; CHECK: .LBB1_7:
+; CHECK: .LBB{{[0-9]+}}_7:
 ; CHECK:   call foo5{{$}}
-; CHECK: .LBB1_8:
+; CHECK: .LBB{{[0-9]+}}_8:
 ; CHECK:   return{{$}}
 define void @bar64(i64 %n) {
 entry:
   switch i64 %n, label %sw.epilog [
     i64 0, label %sw.bb
     i64 1, label %sw.bb
     i64 2, label %sw.bb
     i64 3, label %sw.bb