[WebAssembly] Improve readability of EH tests

[aheejin]

Summary

• Indent check lines to easily figure out try-catch-end structure
• Add the original C++ code the tests were genereated from
• Add a few more lines to make the structure more readable
• Rename a couple function / structures
• Temporarily delete check lines for test1 in cfg-stackify-eh.ll because it will be updated in a later CL soon and there's no point of making these look better here

[aheejin]

rebase

[aheejin]

• More work

[aheejin]

• Add block / end_blocks as well to make structure clearer

[aheejin]

Add back CHECK lines for test2 in cfg-stackify-eh.ll
(turns out it is not gonna change in D58486)

[aheejin]

Add label and branch annotations to cfg-stackify-eh.ll

[aheejin]

Add annotations to rethrow too

[dschuff]

LGTM, this is a nice improvement.

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

94

Could you be more specific here? e.g. "fill in the check lines when we are able to compile this" or "when XXX condition is met"

[aheejin]

Address comment

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

94

Done. And it's gonna be filled in in D58605. (With that bug, the indentation cannot be done here because that bug creates incorrect structures like

try
  block
catch
  end_block
end_try

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

-; RUN: llc < %s -asm-verbose=false -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 -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
 
 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*
 
 ; Simple test case with two catch clauses
+;
+; void foo();
 ; void test0() {
 ;   try {
 ;     foo();
-;   } catch (int n) {
-;     bar();
-;   } catch (double d) {
+;   } catch (int) {
+;   } catch (double) {
 ;   }
 ; }
 
 ; CHECK-LABEL: test0
+; CHECK: block
 ; CHECK:   try
-; CHECK:   call      foo
-; CHECK:   catch     $[[EXCEPT_REF:[0-9]+]]=
-; CHECK:   block i32
-; CHECK:   br_on_exn 0, __cpp_exception, $[[EXCEPT_REF]]
-; CHECK:   rethrow
-; CHECK:   end_block
-; CHECK:   i32.call  $drop=, _Unwind_CallPersonality
-; CHECK:   end_try
-; CHECK:   return
+; CHECK:     call      foo
+; CHECK:     br        0                               # 0: down to label1
+; CHECK:   catch
+; CHECK:     block
+; CHECK:       br_if     0, {{.*}}                     # 0: down to label3
+; CHECK:       i32.call  $drop=, __cxa_begin_catch
+; CHECK:       call      __cxa_end_catch
+; CHECK:       br        1                             # 1: down to label1
+; CHECK:     end_block                                 # label3:
+; CHECK:     block
+; CHECK:       br_if     0, {{.*}}                     # 0: down to label4
+; CHECK:       i32.call  $drop=, __cxa_begin_catch
+; CHECK:       call      __cxa_end_catch
+; CHECK:       br        1                             # 1: down to label1
+; CHECK:     end_block                                 # label4:
+; CHECK:     call      __cxa_rethrow
+; CHECK:   end_try                                     # label1:
+; CHECK: end_block
 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
 
 catch.start:                                      ; preds = %catch.dispatch
   %1 = catchpad within %0 [i8* bitcast (i8** @_ZTIi to i8*), i8* bitcast (i8** @_ZTId to i8*)]
   %2 = call i8* @llvm.wasm.get.exception(token %1)
   %3 = call i32 @llvm.wasm.get.ehselector(token %1)
   %4 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %3, %4
   br i1 %matches, label %catch2, label %catch.fallthrough
 
 catch2:                                           ; preds = %catch.start
   %5 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
-  %6 = bitcast i8* %5 to i32*
-  %7 = load i32, i32* %6, align 4
-  call void @bar() [ "funclet"(token %1) ]
   call void @__cxa_end_catch() [ "funclet"(token %1) ]
   catchret from %1 to label %try.cont
 
 catch.fallthrough:                                ; preds = %catch.start
-  %8 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTId to i8*))
-  %matches1 = icmp eq i32 %3, %8
+  %6 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTId to i8*))
+  %matches1 = icmp eq i32 %3, %6
   br i1 %matches1, label %catch, label %rethrow
 
 catch:                                            ; preds = %catch.fallthrough
-  %9 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
-  %10 = bitcast i8* %9 to double*
-  %11 = load double, double* %10, align 8
+  %7 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
   call void @__cxa_end_catch() [ "funclet"(token %1) ]
   catchret from %1 to label %try.cont
 
 rethrow:                                          ; preds = %catch.fallthrough
   call void @__cxa_rethrow() [ "funclet"(token %1) ]
   unreachable
 
 try.cont:                                         ; preds = %entry, %catch, %catch2
   ret void
 }
 
 ; Nested try-catches within a catch
 ; void test1() {
 ;   try {
 ;     foo();
-;   } catch (int n) {
+;   } catch (int) {
 ;     try {
 ;       foo();
-;     } catch (int n) {
+;     } catch (int) {
 ;       foo();
 ;     }
 ;   }
 ; }
 
 ; CHECK-LABEL: test1
-; CHECK:   try
-; CHECK:   call      foo
-; CHECK:   catch
-; CHECK:   br_on_exn 0, __cpp_exception
-; CHECK:   rethrow
-; CHECK:   i32.call  $drop=, _Unwind_CallPersonality
-; CHECK:   try
-; CHECK:   call      foo
-; CHECK:   catch
-; CHECK:   br_on_exn   0, __cpp_exception
-; CHECK:   rethrow
-; CHECK:   i32.call  $drop=, _Unwind_CallPersonality
-; CHECK:   try
-; CHECK:   i32.call  $drop=, __cxa_begin_catch
-; CHECK:   try
-; CHECK:   call      foo
-; CHECK:   catch     $drop=
-; CHECK:   rethrow
-; CHECK:   end_try
-; CHECK:   catch     $drop=
-; CHECK:   rethrow
-; CHECK:   end_try
-; CHECK:   end_try
-; CHECK:   end_try
-; CHECK:   return
+; TODO Fill in check lines
 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
   %0 = catchswitch within none [label %catch.start] unwind to caller
 

 ;     foo();
 ;   } catch (...) {
 ;     for (int i = 0; i < 50; i++)
 ;       foo();
 ;   }
 ; }
 
 ; CHECK-LABEL: test2
+; CHECK: block
 ; CHECK:   try
-; CHECK:   call      foo
+; CHECK:     call      foo
+; CHECK:     br        0                               # 0: down to label17
 ; CHECK:   catch
-; CHECK:   br_on_exn   0, __cpp_exception
-; CHECK:   rethrow
-; CHECK:   loop
-; CHECK:   try
-; CHECK:   call      foo
-; CHECK:   catch     $drop=
-; CHECK:   try
-; CHECK:   call      __cxa_end_catch
-; CHECK:   catch
-; CHECK:   br_on_exn   0, __cpp_exception
-; CHECK:   call      __clang_call_terminate, 0
-; CHECK:   unreachable
-; CHECK:   call      __clang_call_terminate
-; CHECK:   unreachable
-; CHECK:   end_try
-; CHECK:   rethrow
-; CHECK:   end_try
-; CHECK:   end_loop
-; CHECK:   end_try
-; CHECK:   return
+; CHECK:     i32.call  $drop=, __cxa_begin_catch
+; CHECK:     loop                                      # label19:
+; CHECK:       block
+; CHECK:         block
+; CHECK:           br_if     0, {{.*}}                 # 0: down to label21
+; CHECK:           try
+; CHECK:             call      foo
+; CHECK:             br        2                       # 2: down to label20
+; CHECK:           catch
+; CHECK:             block
+; CHECK:               try
+; CHECK:                 call      __cxa_end_catch
+; CHECK:                 br        0                   # 0: down to label24
+; CHECK:               catch
+; CHECK:                 call      __clang_call_terminate
+; CHECK:                 unreachable
+; CHECK:               end_try                         # label24:
+; CHECK:             end_block
+; CHECK:             rethrow
+; CHECK:           end_try
+; CHECK:         end_block                             # label21:
+; CHECK:         call      __cxa_end_catch
+; CHECK:         br        2                           # 2: down to label17
+; CHECK:       end_block                               # label20:
+; CHECK:       br        0                             # 0: up to label19
+; CHECK:     end_loop
+; CHECK:   end_try                                     # label17:
+; CHECK: end_block
 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
 

test/CodeGen/WebAssembly/exception.ll

 ; RUN: not llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -exception-model=wasm
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs | FileCheck -allow-deprecated-dag-overlap %s
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-%struct.Cleanup = type { i8 }
+%struct.Temp = type { i8 }
 
 @_ZTIi = external constant i8*
 
 ; CHECK-LABEL: test_throw:
-; CHECK: throw __cpp_exception, $0
-; CHECK-NOT:  unreachable
+; CHECK:     throw __cpp_exception, $0
+; CHECK-NOT: unreachable
 define void @test_throw(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret void
 }
 
 ; CHECK-LABEL: test_rethrow:
-; CHECK:      rethrow
-; CHECK-NOT:  unreachable
+; CHECK:     rethrow
+; CHECK-NOT: unreachable
 define void @test_rethrow(i8* %p) {
   call void @llvm.wasm.rethrow()
   ret void
 }
 
-; CHECK-LABEL: test_catch_rethrow:
-; CHECK:   global.get  ${{.+}}=, __stack_pointer
-; CHECK:   try
-; CHECK:   call      foo
-; CHECK:   catch     $[[EXCEPT_REF:[0-9]+]]=
-; CHECK:   global.set  __stack_pointer
-; CHECK:   block i32
-; CHECK:   br_on_exn 0, __cpp_exception, $[[EXCEPT_REF]]
-; CHECK:   rethrow
-; CHECK:   end_block
-; CHECK:   extract_exception $[[EXN:[0-9]+]]=
-; CHECK-DAG:   i32.store  __wasm_lpad_context
-; CHECK-DAG:   i32.store  __wasm_lpad_context+4
-; CHECK:   i32.call  $drop=, _Unwind_CallPersonality, $[[EXN]]
-; CHECK:   i32.call  $drop=, __cxa_begin_catch
-; CHECK:   call      __cxa_end_catch
-; CHECK:   call      __cxa_rethrow
-; CHECK:   end_try
-define void @test_catch_rethrow() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; Simple test with a try-catch
+;
+; void foo();
+; void test_catch() {
+;   try {
+;     foo();
+;   } catch (int) {
+;   }
+; }
+
+; CHECK-LABEL: test_catch:
+; CHECK:     global.get  ${{.+}}=, __stack_pointer
+; CHECK:     block
+; CHECK:       try
+; CHECK:         call      foo
+; CHECK:         br        0
+; CHECK:       catch     $[[EXCEPT_REF:[0-9]+]]=
+; CHECK:         global.set  __stack_pointer
+; CHECK:         block i32
+; CHECK:           br_on_exn 0, __cpp_exception, $[[EXCEPT_REF]]
+; CHECK:           rethrow
+; CHECK:         end_block
+; CHECK:         extract_exception $[[EXN:[0-9]+]]=
+; CHECK-DAG:     i32.store  __wasm_lpad_context
+; CHECK-DAG:     i32.store  __wasm_lpad_context+4
+; CHECK:         i32.call  $drop=, _Unwind_CallPersonality, $[[EXN]]
+; CHECK:         block
+; CHECK:           br_if     0
+; CHECK:           i32.call  $drop=, __cxa_begin_catch
+; CHECK:           call      __cxa_end_catch
+; CHECK:           br        1
+; CHECK:         end_block
+; CHECK:         call      __cxa_rethrow
+; CHECK:       end_try
+; CHECK:     end_block
+define void @test_catch() 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
 
 catch.start:                                      ; preds = %catch.dispatch

 rethrow:                                          ; preds = %catch.start
   call void @__cxa_rethrow() [ "funclet"(token %1) ]
   unreachable
 
 try.cont:                                         ; preds = %entry, %catch
   ret void
 }
 
+; Destructor (cleanup) test
+;
+; void foo();
+; struct Temp {
+;   ~Temp() {}
+; };
+; void test_cleanup() {
+;   Temp t;
+;   foo();
+; }
+
 ; CHECK-LABEL: test_cleanup:
+; CHECK: block
 ; CHECK:   try
-; CHECK:   call      foo
+; CHECK:     call      foo
+; CHECK:     br        0
 ; CHECK:   catch
-; CHECK:   global.set  __stack_pointer
-; CHECK:   i32.call  $drop=, _ZN7CleanupD1Ev
-; CHECK:   rethrow
+; CHECK:     global.set  __stack_pointer
+; CHECK:     i32.call  $drop=, _ZN4TempD2Ev
+; CHECK:     rethrow
 ; CHECK:   end_try
+; CHECK: end_block
 define void @test_cleanup() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
-  %c = alloca %struct.Cleanup, align 1
+  %t = alloca %struct.Temp, align 1
   invoke void @foo()
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
-  %call = call %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* %c)
+  %call = call %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* %t)
   ret void
 
 ehcleanup:                                        ; preds = %entry
   %0 = cleanuppad within none []
-  %call1 = call %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* %c) [ "funclet"(token %0) ]
+  %call1 = call %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* %t) [ "funclet"(token %0) ]
   cleanupret from %0 unwind to caller
 }
 
+; Calling a function that may throw within a 'catch (...)' generates a
+; temrinatepad, because __cxa_end_catch() also can throw within 'catch (...)'.
+;
+; void foo();
+; void test_terminatepad() {
+;   try {
+;     foo();
+;   } catch (...) {
+;     foo();
+;   }
+; }
+
 ; CHECK-LABEL: test_terminatepad
-; CHECK:   catch
-; CHECK:   block     i32
-; CHECK:   br_on_exn   0, __cpp_exception
-; CHECK:   call      __clang_call_terminate, 0
-; CHECK:   unreachable
-; CHECK:   end_block
-; CHECK:   extract_exception
-; CHECK:   call      __clang_call_terminate
-; CHECK:   unreachable
+; CHECK: block
+; CHECK:   try
+; CHECK:     call      foo
+; CHECK:     br        0
+; CHECK:   catch
+; CHECK:     i32.call  $drop=, __cxa_begin_catch
+; CHECK:     block
+; CHECK:       try
+; CHECK:         call      foo
+; CHECK:         br        0
+; CHECK:       catch
+; CHECK:         block
+; CHECK:           try
+; CHECK:             call      __cxa_end_catch
+; CHECK:             br        0
+; CHECK:           catch
+; CHECK:             block     i32
+; CHECK:               br_on_exn   0, __cpp_exception
+; CHECK:               call      __clang_call_terminate, 0
+; CHECK:               unreachable
+; CHECK:             end_block
+; CHECK:             call      __clang_call_terminate
+; CHECK:             unreachable
+; CHECK:           end_try
+; CHECK:         end_block
+; CHECK:         rethrow
+; CHECK:       end_try
+; CHECK:     end_block
+; CHECK:     call      __cxa_end_catch
+; CHECK:   end_try
+; CHECK: end_block
 define void @test_terminatepad() 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
 
terminate:                                        ; preds = %ehcleanup
   unreachable
 }
 
 ; Tests prologues and epilogues are not generated within EH scopes.
 ; They should not be treated as funclets; BBs starting with a catch instruction
 ; should not have a prologue, and BBs ending with a catchret/cleanupret should
 ; not have an epilogue. This is separate from __stack_pointer restoring
 ; instructions after a catch instruction.
+;
+; void bar(int) noexcept;
+; void test_no_prolog_epilog_in_ehpad() {
+;   int stack_var = 0;
+;   bar(stack_var);
+;   try {
+;     foo();
+;   } catch (int) {
+;     foo();
+;   }
+; }
 
 ; CHECK-LABEL: test_no_prolog_epilog_in_ehpad
-; CHECK:  try
-; CHECK:  call      foo
-; CHECK:  catch
-; CHECK-NOT:  global.get  $push{{.+}}=, __stack_pointer
-; CHECK:  global.set  __stack_pointer
-; CHECK:  try
-; CHECK:  call      foo
-; CHECK:  catch
-; CHECK-NOT:  global.get  $push{{.+}}=, __stack_pointer
-; CHECK:  global.set  __stack_pointer
-; CHECK:  call      __cxa_end_catch
-; CHECK-NOT:  global.set  __stack_pointer, $pop{{.+}}
-; CHECK:  end_try
-; CHECK-NOT:  global.set  __stack_pointer, $pop{{.+}}
-; CHECK:  end_try
+; CHECK:     block
+; CHECK:       try
+; CHECK:         call      foo
+; CHECK:         br        0
+; CHECK:       catch
+; CHECK-NOT:     global.get  $push{{.+}}=, __stack_pointer
+; CHECK:         global.set  __stack_pointer
+; CHECK:         block
+; CHECK:           block
+; CHECK:             br_if     0
+; CHECK:             i32.call  $drop=, __cxa_begin_catch
+; CHECK:             try
+; CHECK:               call      foo
+; CHECK:               br        2
+; CHECK:             catch
+; CHECK-NOT:           global.get  $push{{.+}}=, __stack_pointer
+; CHECK:               global.set  __stack_pointer
+; CHECK:               call      __cxa_end_catch
+; CHECK:               rethrow
+; CHECK-NOT:           global.set  __stack_pointer, $pop{{.+}}
+; CHECK:             end_try
+; CHECK:           end_block
+; CHECK:           call      __cxa_rethrow
+; CHECK:         end_block
+; CHECK-NOT:     global.set  __stack_pointer, $pop{{.+}}
+; CHECK:         call      __cxa_end_catch
+; CHECK:       end_try
+; CHECK:     end_block
 define void @test_no_prolog_epilog_in_ehpad() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
   %stack_var = alloca i32, align 4
   call void @bar(i32* %stack_var)
   invoke void @foo()
           to label %try.cont unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry

 ehcleanup:                                        ; preds = %catch
   %8 = cleanuppad within %1 []
   call void @__cxa_end_catch() [ "funclet"(token %8) ]
   cleanupret from %8 unwind to caller
 }
 
 ; When a function does not have stack-allocated objects, it does not need to
 ; store SP back to __stack_pointer global at the epilog.
+;
+; void foo();
+; void test_no_sp_writeback() {
+;   try {
+;     foo();
+;   } catch (...) {
+;   }
+; }
 
-; CHECK-LABEL: no_sp_writeback
-; CHECK:  try
-; CHECK:  call foo
-; CHECK:  end_try
-; CHECK-NOT:  global.set  __stack_pointer
-; CHECK:  return
-define void @no_sp_writeback() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: test_no_sp_writeback
+; CHECK:     block
+; CHECK:       try
+; CHECK:         call      foo
+; CHECK:         br        0
+; CHECK:       catch
+; CHECK:         i32.call  $drop=, __cxa_begin_catch
+; CHECK:         call      __cxa_end_catch
+; CHECK:       end_try
+; CHECK:     end_block
+; CHECK-NOT: global.set  __stack_pointer
+; CHECK:     return
+define void @test_no_sp_writeback() 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
 
 catch.start:                                      ; preds = %catch.dispatch

 declare void @llvm.wasm.rethrow()
 declare i8* @llvm.wasm.get.exception(token)
 declare i32 @llvm.wasm.get.ehselector(token)
 declare i32 @llvm.eh.typeid.for(i8*)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 declare void @__cxa_rethrow()
 declare void @__clang_call_terminate(i8*)
-declare %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* returned)
+declare %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* returned)
 
 ; CHECK: __cpp_exception:
 ; CHECK: .eventtype  __cpp_exception i32

test/CodeGen/WebAssembly/wasmehprepare.ll

 ; RUN: opt < %s -winehprepare -demote-catchswitch-only -wasmehprepare -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK: @__wasm_lpad_context = external global { i32, i8*, i32 }
 
 @_ZTIi = external constant i8*
-%struct.Cleanup = type { i8 }
+%struct.Temp = type { i8 }
 
 ; A single 'catch (int)' clause.
 ; A wasm.catch() call, wasm.lsda() call, and personality call to generate a
 ; selector should all be genereated after the catchpad.
+;
+; void foo();
+; void test0() {
+;   try {
+;     foo();
+;   } catch (int) {
+;   }
+; }
 define void @test0() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 ; CHECK-LABEL: @test0()
 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

 rethrow:                                          ; preds = %catch.start
   call void @__cxa_rethrow() [ "funclet"(token %1) ]
   unreachable
 
 try.cont:                                         ; preds = %entry, %catch
   ret void
 }
 
-; Two try-catches, one of them is with a single 'catch (...)' clause.
+; Two try-catches.
 ; For the catchpad with a single 'catch (...)', only a wasm.catch() call should
 ; be generated after the catchpad; wasm.landingpad.index() and personality call
 ; should NOT be generated. For the other catchpad, the argument of
 ; wasm.landingpad.index() should be not 1 but 0.
+;
+; void foo();
+; void test1() {
+;   try {
+;     foo();
+;   } catch (...) {
+;   }
+;   try {
+;     foo();
+;   } catch (int) {
+;   }
+; }
 define void @test1() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 ; CHECK-LABEL: @test1()
 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

 rethrow:                                          ; preds = %catch.start3
   call void @__cxa_rethrow() [ "funclet"(token %6) ]
   unreachable
 
 try.cont7:                                        ; preds = %try.cont, %catch4
   ret void
 }
 
-; A nested try-catch within a catch. Within the nested catchpad, wasm.lsda()
-; call should NOT be generated.
+; A nested try-catch within a catch.
+;
+; void foo();
+; void test2() {
+;   try {
+;     foo();
+;   } catch (int) {
+;     try {
+;       foo();
+;     } catch (int) {
+;     }
+;   }
+; }
+; Within the nested catchpad, wasm.lsda() call should NOT be generated.
 define void @test2() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 ; CHECK-LABEL: @test2()
 entry:
   invoke void @foo()
           to label %try.cont9 unwind label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %entry
   %0 = catchswitch within none [label %catch.start] unwind to caller

 ; CHECK-NOT:   load {{.*}} @__wasm_lpad_context
 
 unreachable:                                      ; preds = %rethrow5
   unreachable
 }
 
 ; A cleanuppad with a call to __clang_call_terminate().
 ; A call to wasm.catch() should be generated after the cleanuppad.
+;
+; void foo();
+; void test3() {
+;   try {
+;     foo();
+;   } catch (...) {
+;     foo();
+;   }
+; }
 define void @test3() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 ; CHECK-LABEL: @test3
 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: terminate:
 ; CHECK-NEXT: cleanuppad
 ; CHECK-NEXT:   %[[EXN:.*]] = call i8* @llvm.wasm.extract.exception
 ; CHECK-NEXT:   call void @__clang_call_terminate(i8* %[[EXN]])
 }
 
 ; PHI demotion test. Only the phi before catchswitch should be demoted; the phi
 ; before cleanuppad should NOT.
+
+; void foo();
+; int bar(int) noexcept;
+; struct Temp {
+;   ~Temp() {}
+; };
+;
+; void test4() {
+;   int num;
+;   try {
+;     Temp t;
+;     num = 1;
+;     foo();
+;     num = 2;
+;     foo();
+;   } catch (...) {
+;     bar(num);
+;   }
+;   try {
+;     foo();
+;     num = 1;
+;     foo();
+;     num = 2;
+;   } catch (...) {
+;     bar(num);
+;   }
+; }
 define void @test4() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 ; CHECK-LABEL: @test4
 entry:
-  %c = alloca %struct.Cleanup, align 1
+  %t = alloca %struct.Temp, align 1
   invoke void @foo()
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry
   invoke void @foo()
           to label %invoke.cont1 unwind label %ehcleanup
 
 invoke.cont1:                                     ; preds = %invoke.cont
-  %call = call %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* %c)
+  %call = call %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* %t)
   br label %try.cont
 
 ehcleanup:                                        ; preds = %invoke.cont, %entry
   %num.0 = phi i32 [ 2, %invoke.cont ], [ 1, %entry ]
   %0 = cleanuppad within none []
-  %call2 = call %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* %c) [ "funclet"(token %0) ]
+  %call2 = call %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* %t) [ "funclet"(token %0) ]
   cleanupret from %0 unwind label %catch.dispatch
 ; CHECK: ehcleanup:
 ; CHECK-NEXT:   = phi
 
 catch.dispatch:                                   ; preds = %ehcleanup
   %1 = catchswitch within none [label %catch.start] unwind to caller
 
 catch.start:                                      ; preds = %catch.dispatch
   %2 = catchpad within %1 [i8* null]
   %3 = call i8* @llvm.wasm.get.exception(token %2)
   %4 = call i32 @llvm.wasm.get.ehselector(token %2)
   %5 = call i8* @__cxa_begin_catch(i8* %3) [ "funclet"(token %2) ]
-  call void @func(i32 %num.0) [ "funclet"(token %2) ]
+  call void @bar(i32 %num.0) [ "funclet"(token %2) ]
   call void @__cxa_end_catch() [ "funclet"(token %2) ]
   catchret from %2 to label %try.cont
 
 try.cont:                                         ; preds = %catch.start, %invoke.cont1
   invoke void @foo()
           to label %invoke.cont3 unwind label %catch.dispatch5
 
 invoke.cont3:                                     ; preds = %try.cont
   invoke void @foo()
           to label %try.cont10 unwind label %catch.dispatch5
 
 catch.dispatch5:                                  ; preds = %invoke.cont3, %try.cont
   %num.1 = phi i32 [ 2, %invoke.cont3 ], [ 1, %try.cont ]
   %6 = catchswitch within none [label %catch.start6] unwind to caller
 ; CHECK: catch.dispatch5:
 ; CHECK-NOT:   = phi
 
 catch.start6:                                     ; preds = %catch.dispatch5
   %7 = catchpad within %6 [i8* null]
   %8 = call i8* @llvm.wasm.get.exception(token %7)
   %9 = call i32 @llvm.wasm.get.ehselector(token %7)
   %10 = call i8* @__cxa_begin_catch(i8* %8) [ "funclet"(token %7) ]
-  call void @func(i32 %num.1) [ "funclet"(token %7) ]
+  call void @bar(i32 %num.1) [ "funclet"(token %7) ]
   call void @__cxa_end_catch() [ "funclet"(token %7) ]
   catchret from %7 to label %try.cont10
 
 try.cont10:                                       ; preds = %invoke.cont3, %catch.start6
   ret void
 }
 
 ; Tests if instructions after a call to @llvm.wasm.throw are deleted and the
bb.false:                                         ; preds = %entry
   br label %merge
 
 ; CHECK:      merge
 merge:                                            ; preds = %bb.true.0, %bb.false
   ret i32 0
 }
 
 declare void @foo()
-declare void @func(i32)
-declare %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* returned)
+declare void @bar(i32)
+declare %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* returned)
 declare i32 @__gxx_wasm_personality_v0(...)
 declare i8* @llvm.wasm.get.exception(token)
 declare i32 @llvm.wasm.get.ehselector(token)
 declare i32 @llvm.eh.typeid.for(i8*)
 declare void @llvm.wasm.throw(i32, i8*)
 declare void @llvm.wasm.rethrow()
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 declare void @__cxa_rethrow()
 declare void @__clang_call_terminate(i8*)
 
 ; CHECK-DAG: declare void @llvm.wasm.landingpad.index(token, i32)
 ; CHECK-DAG: declare i8* @llvm.wasm.lsda()
 ; CHECK-DAG: declare i32 @_Unwind_CallPersonality(i8*)