[WebAssembly] Change label numbers to variables in test

[aheejin]

Summary

cfg-stackify-eh.ll contains many CHECK lines specifying label / catch
comments with numbers. These numbers are subject to change every time
any block/loop/try is added in the middle in existing functions or any
other function is added in the middle of the file, generating a large
number of lines in diffs. This change converts them to variables so they
can be more resistent to future changes.

[tlively]

Looks good! A few of the replacements in the code don't match the replacements in the comments, but I assume the comments were previously just stale.

llvm/test/CodeGen/WebAssembly/cfg-stackify-eh.ll

440

This should have been label35 rather than label4 previously, right?

581

And catch19 should have been catch23?

[aheejin]

llvm/test/CodeGen/WebAssembly/cfg-stackify-eh.ll

440

Yes, the comment looks stale already. Hope this CL prevents something like this in future...

581

Yes here too. These numbers changed whenever I added a test in the middle.

llvm/test/CodeGen/WebAssembly/cfg-stackify-eh.ll

 ; REQUIRES: asserts
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 -exception-model=wasm -mattr=+exception-handling | FileCheck %s
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 -exception-model=wasm -mattr=+exception-handling
 ; RUN: llc < %s -O0 -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -verify-machineinstrs -exception-model=wasm -mattr=+exception-handling | FileCheck %s --check-prefix=NOOPT
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 -exception-model=wasm -mattr=+exception-handling -wasm-disable-ehpad-sort | FileCheck %s --check-prefix=NOSORT
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 -exception-model=wasm -mattr=+exception-handling -wasm-disable-ehpad-sort | FileCheck %s --check-prefix=NOSORT-LOCALS
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 -exception-model=wasm -mattr=+exception-handling -wasm-disable-ehpad-sort -stats 2>&1 | FileCheck %s --check-prefix=NOSORT-STAT
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 @_ZTIi = external constant i8*
 @_ZTId = external constant i8*
 
+%class.Object = type { i8 }
+%class.MyClass = type { i32 }
+
 ; Simple test case with two catch clauses
 ;
 ; void foo();
 ; void test0() {
 ;   try {
 ;     foo();
 ;   } catch (int) {
 ;   } catch (double) {
 ;   }
 ; }
 
 ; CHECK-LABEL: test0
 ; CHECK: try
 ; CHECK:   call      foo
 ; CHECK: catch
 ; CHECK:   block
-; CHECK:     br_if     0, {{.*}}                       # 0: down to label2
+; CHECK:     br_if     0, {{.*}}                       # 0: down to label[[L0:[0-9]+]]
 ; CHECK:     call      $drop=, __cxa_begin_catch
 ; CHECK:     call      __cxa_end_catch
-; CHECK:     br        1                               # 1: down to label0
-; CHECK:   end_block                                   # label2:
+; CHECK:     br        1                               # 1: down to label[[L1:[0-9]+]]
+; CHECK:   end_block                                   # label[[L0]]:
 ; CHECK:   block
-; CHECK:     br_if     0, {{.*}}                       # 0: down to label3
+; CHECK:     br_if     0, {{.*}}                       # 0: down to label[[L2:[0-9]+]]
 ; CHECK:     call      $drop=, __cxa_begin_catch
 ; CHECK:     call      __cxa_end_catch
-; CHECK:     br        1                               # 1: down to label0
-; CHECK:   end_block                                   # label3:
+; CHECK:     br        1                               # 1: down to label[[L1]]
+; CHECK:   end_block                                   # label[[L2]]:
 ; CHECK:   rethrow   {{.*}}                            # to caller
-; CHECK: end_try                                       # label0:
+; CHECK: end_try                                       # label[[L1]]:
 define void @test0() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
   invoke void @foo()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
   %0 = catchswitch within none [label %catch.start] unwind to caller
 

 ; }
 
 ; CHECK-LABEL: test1
 ; CHECK: try
 ; CHECK:   call      foo
 ; CHECK: catch
 ; CHECK:   block
 ; CHECK:     block
-; CHECK:       br_if     0, {{.*}}                     # 0: down to label7
+; CHECK:       br_if     0, {{.*}}                     # 0: down to label[[L0:[0-9]+]]
 ; CHECK:       call      $drop=, __cxa_begin_catch
 ; CHECK:       try
 ; CHECK:         call      foo
-; CHECK:         br        2                           # 2: down to label6
+; CHECK:         br        2                           # 2: down to label[[L1:[0-9]+]]
 ; CHECK:       catch
 ; CHECK:         try
 ; CHECK:           block
-; CHECK:             br_if     0, {{.*}}               # 0: down to label11
+; CHECK:             br_if     0, {{.*}}               # 0: down to label[[L2:[0-9]+]]
 ; CHECK:             call      $drop=, __cxa_begin_catch
 ; CHECK:             try
 ; CHECK:               call      foo
-; CHECK:               br        2                     # 2: down to label9
+; CHECK:               br        2                     # 2: down to label[[L3:[0-9]+]]
 ; CHECK:             catch
 ; CHECK:               call      __cxa_end_catch
-; CHECK:               rethrow   {{.*}}                # down to catch3
+; CHECK:               rethrow   {{.*}}                # down to catch[[C0:[0-9]+]]
 ; CHECK:             end_try
-; CHECK:           end_block                           # label11:
-; CHECK:           rethrow   {{.*}}                    # down to catch3
-; CHECK:         catch     {{.*}}                      # catch3:
+; CHECK:           end_block                           # label[[L2]]:
+; CHECK:           rethrow   {{.*}}                    # down to catch[[C0]]
+; CHECK:         catch     {{.*}}                      # catch[[C0]]:
 ; CHECK:           call      __cxa_end_catch
 ; CHECK:           rethrow   {{.*}}                    # to caller
-; CHECK:         end_try                               # label9:
+; CHECK:         end_try                               # label[[L3]]:
 ; CHECK:         call      __cxa_end_catch
-; CHECK:         br        2                           # 2: down to label6
+; CHECK:         br        2                           # 2: down to label[[L1]]
 ; CHECK:       end_try
-; CHECK:     end_block                                 # label7:
+; CHECK:     end_block                                 # label[[L0]]:
 ; CHECK:     rethrow   {{.*}}                          # to caller
-; CHECK:   end_block                                   # label6:
+; CHECK:   end_block                                   # label[[L1]]:
 ; CHECK:   call      __cxa_end_catch
 ; CHECK: end_try
 define void @test1() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
   invoke void @foo()
           to label %try.cont11 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry

 ;   }
 ; }
 
 ; CHECK-LABEL: test2
 ; CHECK: try
 ; CHECK:   call      foo
 ; CHECK: catch
 ; CHECK:   call      $drop=, __cxa_begin_catch
-; CHECK:   loop                                        # label15:
+; CHECK:   loop                                        # label[[L0:[0-9]+]]:
 ; CHECK:     block
 ; CHECK:       block
-; CHECK:         br_if     0, {{.*}}                   # 0: down to label17
+; CHECK:         br_if     0, {{.*}}                   # 0: down to label[[L1:[0-9]+]]
 ; CHECK:         try
 ; CHECK:           call      foo
-; CHECK:           br        2                         # 2: down to label16
+; CHECK:           br        2                         # 2: down to label[[L2:[0-9]+]]
 ; CHECK:         catch
 ; CHECK:           try
 ; CHECK:             call      __cxa_end_catch
 ; CHECK:           catch
 ; CHECK:             call      __clang_call_terminate
 ; CHECK:             unreachable
 ; CHECK:           end_try
 ; CHECK:           rethrow   {{.*}}                    # to caller
 ; CHECK:         end_try
-; CHECK:       end_block                               # label17:
+; CHECK:       end_block                               # label[[L1]]:
 ; CHECK:       call      __cxa_end_catch
-; CHECK:       br        2                             # 2: down to label13
-; CHECK:     end_block                                 # label16:
-; CHECK:     br        0                               # 0: up to label15
+; CHECK:       br        2                             # 2: down to label[[L3:[0-9]+]]
+; CHECK:     end_block                                 # label[[L2]]:
+; CHECK:     br        0                               # 0: up to label[[L0]]
 ; CHECK:   end_loop
-; CHECK: end_try                                       # label13:
+; CHECK: end_try                                       # label[[L3]]:
 define void @test2() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
   invoke void @foo()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
   %0 = catchswitch within none [label %catch.start] unwind to caller
 
try.cont:                                         ; preds = %catch.start, %loop
   br label %loop
 }
 
 ; Some of test cases below are hand-tweaked by deleting some library calls to
 ; simplify tests and changing the order of basic blocks to cause unwind
 ; destination mismatches. And we use -wasm-disable-ehpad-sort to create maximum
 ; number of mismatches in several tests below.
 
-; 'call bar''s original unwind destination was 'catch14', but after control flow
-; linearization, its unwind destination incorrectly becomes 'catch15'. We fix
-; this by wrapping the call with a nested try/catch/end_try and branching to the
-; right destination (label32).
+; 'call bar''s original unwind destination was 'C1', but after control flow
+; linearization, its unwind destination incorrectly becomes 'C0'. We fix this by
+; wrapping the call with a nested try/catch/end_try and branching to the right
+; destination (L0).
 
 ; NOSORT-LABEL: test5
 ; NOSORT:   block
 ; NOSORT:     try
 ; NOSORT:       try
 ; NOSORT:         call      foo
 ; --- Nested try/catch/end_try starts
 ; NOSORT:         try
 ; NOSORT:           call      bar
 ; NOSORT:         catch     $drop=
-; NOSORT:           br        2                        # 2: down to label32
+; NOSORT:           br        2                        # 2: down to label[[L0:[0-9]+]]
 ; NOSORT:         end_try
 ; --- Nested try/catch/end_try ends
-; NOSORT:         br        2                          # 2: down to label31
-; NOSORT:       catch     $drop=                       # catch15:
-; NOSORT:         br        2                          # 2: down to label31
+; NOSORT:         br        2                          # 2: down to label[[L1:[0-9]+]]
+; NOSORT:       catch     $drop=                       # catch[[C0:[0-9]+]]:
+; NOSORT:         br        2                          # 2: down to label[[L1]]
 ; NOSORT:       end_try
-; NOSORT:     catch     $drop=                         # catch14:
-; NOSORT:     end_try                                  # label32:
-; NOSORT:   end_block                                  # label31:
+; NOSORT:     catch     $drop=                         # catch[[C1:[0-9]+]]:
+; NOSORT:     end_try                                  # label[[L0]]:
+; NOSORT:   end_block                                  # label[[L1]]:
 ; NOSORT:   return
 
 define void @test5() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 bb0:
   invoke void @foo()
           to label %bb1 unwind label %catch.dispatch0
 
 bb1:                                              ; preds = %bb0
catch.start1:                                     ; preds = %catch.dispatch1
   %7 = call i32 @llvm.wasm.get.ehselector(token %5)
   catchret from %5 to label %try.cont
 
 try.cont:                                         ; preds = %catch.start1, %catch.start0, %bb1
   ret void
 }
 
 ; Two 'call bar''s original unwind destination was the caller, but after control
-; flow linearization, their unwind destination incorrectly becomes 'catch17'. We
-; fix this by wrapping the call with a nested try/catch/end_try and branching to
-; the right destination (label4), from which we rethrow the exception to the
-; caller.
+; flow linearization, their unwind destination incorrectly becomes 'C0'. We fix
+; this by wrapping the call with a nested try/catch/end_try and branching to the
+; right destination (L0), from which we rethrow the exception to the caller.
 
 ; And the return value of 'baz' should NOT be stackified because the BB is split
 ; during fixing unwind mismatches.
 
 ; NOSORT-LABEL: test6
 ; NOSORT:   try
 ; NOSORT:     call      foo
 ; --- Nested try/catch/end_try starts
 ; NOSORT:     try
 ; NOSORT:       call      bar
 ; NOSORT:       call      ${{[0-9]+}}=, baz
 ; NOSORT-NOT:   call      $push{{.*}}=, baz
 ; NOSORT:     catch     $[[REG:[0-9]+]]=
-; NOSORT:       br        1                            # 1: down to label35
+; NOSORT:       br        1                            # 1: down to label[[L0:[0-9]+]]
 ; NOSORT:     end_try
 ; --- Nested try/catch/end_try ends
 ; NOSORT:     return
-; NOSORT:   catch     $drop=                           # catch17:
+; NOSORT:   catch     $drop=                           # catch[[C0:[0-9]+]]:
 ; NOSORT:     return
-; NOSORT:   end_try                                    # label35:
+; NOSORT:   end_try                                    # label[[L0]]:
 ; NOSORT:   rethrow   $[[REG]]                         # to caller
 
 define void @test6() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 bb0:
   invoke void @foo()
           to label %bb1 unwind label %catch.dispatch0
 
 bb1:                                              ; preds = %bb0
catch.start0:                                     ; preds = %catch.dispatch0
   catchret from %1 to label %try.cont
 
 try.cont:                                         ; preds = %catch.start0
   ret void
 }
 
 ; Similar situation as @test6. Here 'call @qux''s original unwind destination
 ; was the caller, but after control flow linearization, their unwind destination
-; incorrectly becomes another catch within the function. We fix this by wrapping
-; the call with a nested try/catch/end_try and branching to the right
-; destination, from which we rethrow the exception to the caller.
+; incorrectly becomes 'C0' within the function. We fix this by wrapping the call
+; with a nested try/catch/end_try and branching to the right destination, from
+; which we rethrow the exception to the caller.
 
 ; Because 'call @qux' pops an argument pushed by 'i32.const 5' from stack, the
 ; nested 'try' should be placed before `i32.const 5', not between 'i32.const 5'
 ; and 'call @qux'.
 
 ; NOSORT-LABEL: test7
 ; NOSORT:   try
 ; NOSORT:     call      foo
 ; --- Nested try/catch/end_try starts
 ; NOSORT:     try
 ; NOSORT-NEXT:  i32.const $push{{[0-9]+}}=, 5
 ; NOSORT-NEXT:  call      ${{[0-9]+}}=, qux
 ; NOSORT:     catch     $[[REG:[0-9]+]]=
-; NOSORT:       br        1                            # 1: down to label37
+; NOSORT:       br        1                            # 1: down to label[[L0:[0-9]+]]
 ; NOSORT:     end_try
 ; --- Nested try/catch/end_try ends
 ; NOSORT:     return
-; NOSORT:   catch     $drop=                           # catch19:
+; NOSORT:   catch     $drop=                           # catch[[C0:[0-9]+]]:
 ; NOSORT:     return
-; NOSORT:   end_try                                    # label37:
+; NOSORT:   end_try                                    # label[[L0]]:
 ; NOSORT:   rethrow   $[[REG]]                         # to caller
 
 define i32 @test7() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 bb0:
   invoke void @foo()
           to label %bb1 unwind label %catch.dispatch0
 
 bb1:                                              ; preds = %bb0

 try.cont:                                         ; preds = %catch.start0
   ret void
 }
 
 ; If not for the unwind destination mismatch, the LOOP marker here would have an
 ; i32 signature. But because we add a rethrow instruction at the end of the
 ; appendix block, now the LOOP marker does not have a signature (= has a void
 ; signature). Here the two calls two 'bar' are supposed to throw up to the
-; caller, but incorrectly unwind to 'catch19' after linearizing the CFG.
+; caller, but incorrectly unwind to 'C0' after linearizing the CFG.
 
 ; NOSORT-LABEL: test9
 ; NOSORT: block
 ; NOSORT-NOT: loop      i32
-; NOSORT:   loop                                       # label42:
+; NOSORT:   loop                                       # label[[L0:[0-9]+]]:
 ; NOSORT:     try
 ; NOSORT:       call      foo
 ; --- Nested try/catch/end_try starts
 ; NOSORT:       try
 ; NOSORT:         call      bar
 ; NOSORT:         call      bar
 ; NOSORT:       catch     $[[REG:[0-9]+]]=
-; NOSORT:         br        1                          # 1: down to label43
+; NOSORT:         br        1                          # 1: down to label[[L1:[0-9]+]]
 ; NOSORT:       end_try
 ; --- Nested try/catch/end_try ends
 ; NOSORT:       return    {{.*}}
-; NOSORT:     catch     $drop=                         # catch23:
-; NOSORT:       br        1                            # 1: up to label42
-; NOSORT:     end_try                                  # label43:
+; NOSORT:     catch     $drop=                         # catch[[C0:[0-9]+]]:
+; NOSORT:       br        1                            # 1: up to label[[L0]]
+; NOSORT:     end_try                                  # label[[L1]]:
 ; NOSORT:   end_loop
 ; NOSORT: end_block
 ; NOSORT: rethrow   $[[REG]]                           # to caller
 
 define i32 @test9(i32* %p) personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
   store volatile i32 0, i32* %p
   br label %loop

 ; NOSORT:   block
 ; NOSORT:     try
 ; NOSORT:       try
 ; NOSORT:         call      foo
 ; --- Nested try/catch/end_try starts
 ; NOSORT:         try
 ; NOSORT:           call      bar
 ; NOSORT:         catch     $[[REG0:[0-9]+]]=
-; NOSORT:           br        2                        # 2: down to label47
+; NOSORT:           br        2                        # 2: down to label[[L0:[0-9]+]]
 ; NOSORT:         end_try
 ; --- Nested try/catch/end_try ends
-; NOSORT:         br        2                          # 2: down to label46
+; NOSORT:         br        2                          # 2: down to label[[L1:[0-9]+]]
 ; NOSORT:       catch     {{.*}}
 ; NOSORT:         block     i32
-; NOSORT:           br_on_exn   0, {{.*}}              # 0: down to label50
+; NOSORT:           br_on_exn   0, {{.*}}              # 0: down to label[[L2:[0-9]+]]
 ; --- Nested try/catch/end_try starts
 ; NOSORT:           try
-; NOSORT:             rethrow   {{.*}}                 # down to catch28
-; NOSORT:           catch     $[[REG1:[0-9]+]]=        # catch28:
-; NOSORT:             br        5                      # 5: down to label45
+; NOSORT:             rethrow   {{.*}}                 # down to catch[[C0:[0-9]+]]
+; NOSORT:           catch     $[[REG1:[0-9]+]]=        # catch[[C0]]:
+; NOSORT:             br        5                      # 5: down to label[[L3:[0-9]+]]
 ; NOSORT:           end_try
 ; --- Nested try/catch/end_try ends
-; NOSORT:         end_block                            # label50:
+; NOSORT:         end_block                            # label[[L2]]:
 ; NOSORT:         call      $drop=, __cxa_begin_catch
 ; --- Nested try/catch/end_try starts
 ; NOSORT:         try
 ; NOSORT:           call      __cxa_end_catch
 ; NOSORT:         catch     $[[REG1]]=
-; NOSORT:           br        4                        # 4: down to label45
+; NOSORT:           br        4                        # 4: down to label[[L3]]
 ; NOSORT:         end_try
 ; --- Nested try/catch/end_try ends
-; NOSORT:         br        2                          # 2: down to label46
+; NOSORT:         br        2                          # 2: down to label[[L1]]
 ; NOSORT:       end_try
 ; NOSORT:     catch     $[[REG0]]=
-; NOSORT:     end_try                                  # label47:
+; NOSORT:     end_try                                  # label[[L0]]:
 ; NOSORT:     call      $drop=, __cxa_begin_catch
 ; NOSORT:     call      __cxa_end_catch
-; NOSORT:   end_block                                  # label46:
+; NOSORT:   end_block                                  # label[[L1]]:
 ; NOSORT:   return
-; NOSORT: end_block                                    # label45:
+; NOSORT: end_block                                    # label[[L3]]:
 ; NOSORT: rethrow   $[[REG1]]                          # to caller
 define void @test10() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 bb0:
   invoke void @foo()
           to label %bb1 unwind label %catch.dispatch0
 
 bb1:                                              ; preds = %bb0
   invoke void @bar()

 cont:                                             ; preds = %if.then
   call void @foo()
   br label %if.end
 
 if.end:                                           ; preds = %cont, %catch.start, %entry
   ret void
 }
 
-%class.Object = type { i8 }
-
 ; Intrinsics like memcpy, memmove, and memset don't throw and are lowered into
 ; calls to external symbols (not global addresses) in instruction selection,
 ; which will be eventually lowered to library function calls.
 ; Because this test runs with -wasm-disable-ehpad-sort, these library calls in
 ; invoke.cont BB fall within try~end_try, but they shouldn't cause crashes or
 ; unwinding destination mismatches in CFGStackify.
 
 ; NOSORT-LABEL: test12

 
 terminate:                                        ; preds = %entry
   %0 = cleanuppad within none []
   %1 = tail call i8* @llvm.wasm.get.exception(token %0)
   call void @__clang_call_terminate(i8* %1) [ "funclet"(token %0) ]
   unreachable
 }
 
-%class.MyClass = type { i32 }
-
 ; This crashed on debug mode (= when NDEBUG is not defined) when the logic for
 ; computing the innermost region was not correct, in which a loop region
 ; contains an exception region. This should pass CFGSort without crashing.
 define void @test14() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
   %e = alloca %class.MyClass, align 4
   br label %for.cond