[WebAssembly] Make rethrow take an except_ref type argument

[aheejin]

Summary

In the new wasm EH proposal, rethrow takes an except_ref argument.
This change was missing in D57134 (r352598).

This patch adds llvm.wasm.rethrow.in.catch intrinsic. This is an
intrinsic that's gonna eventually be lowered to wasm rethrow
instruction, but this intrinsic can appear only within a catchpad or a
cleanuppad scope. Also this intrinsic needs to be invokable - otherwise
EH pad successor for it will not be correctly generated in clang.

This also adds lowering logic for this intrinsic in
SelectionDAGBuilder::visitInvoke. This routine is basically a
specialized and simplified version of
SelectionDAGBuilder::visitTargetIntrinsic, but we can't use it
because if is only for CallInsts.

This deletes the previous llvm.wasm.rethrow intrinsic and related
tests, which was meant to be used within a __cxa_rethrow library
function. Turned out this needs some more logic, so the intrinsic for
this purpose will be added later.

LateEHPrepare takes a result value of catch and inserts it into
matching rethrow as an argument.

RETHROW_IN_CATCH is a pseudo instruction that serves as a link between
llvm.wasm.rethrow.in.catch and the real wasm rethrow instruction. To
generate a rethrow instruction, we need an except_ref argument,
which is generated from catch instruction. But catch instrutions are
added in LateEHPrepare pass, so we use RETHROW_IN_CATCH, which takes
no argument, until we are able to correctly lower it to rethrow in
LateEHPrepare.

[aheejin]

Comment fix

[dschuff]

otherwise LGTM

lib/CodeGen/WasmEHPrepare.cpp

180 ↗

(On Diff #190588)

Update the comment too.

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

36 ↗

(On Diff #190588)

Here you are trying to match the $ but below you are not. I guess the reason you are not checking the value (in catch or rethrow) is because these tests are only intended to verify the control flow?

test/CodeGen/WebAssembly/wasmehprepare.ll

399 ↗

(On Diff #190588)

You've removed this test; should we also remove the code that it's testing?

[aheejin]

• Address comments
• Change rethrow definition from NRI to I

[aheejin]

lib/CodeGen/WasmEHPrepare.cpp

180 ↗

(On Diff #190588)

Done.

You've removed this test; should we also remove the code that it's testing?

This is the part where I removed the code for that. Note I deleted the line

for (auto L : {ThrowF->users(), RethrowF->users()}) {

and now the User *U only refers to ThrowF->users().

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

36 ↗

(On Diff #190588)

Yes, I didn't try to check if the argument is correct in this file because this is for CFG ctackify pass checking. But I wasn't gonna make this different from other occurrences in this file by checking $ here only; I will change this to `{{.*}} like others.

test/CodeGen/WebAssembly/wasmehprepare.ll

399 ↗

(On Diff #190588)

I've already done that; please see the comment above in WasmEHPrepare.cpp.

llvm/trunk/include/llvm/IR/IntrinsicsWebAssembly.td

 
 //===----------------------------------------------------------------------===//
 // Exception handling intrinsics
 //===----------------------------------------------------------------------===//
 
 // throw / rethrow
 def int_wasm_throw : Intrinsic<[], [llvm_i32_ty, llvm_ptr_ty],
                                [Throws, IntrNoReturn]>;
-def int_wasm_rethrow : Intrinsic<[], [], [Throws, IntrNoReturn]>;
+def int_wasm_rethrow_in_catch : Intrinsic<[], [], [Throws, IntrNoReturn]>;
 
 // Since wasm does not use landingpad instructions, these instructions return
 // exception pointer and selector values until we lower them in WasmEHPrepare.
 def int_wasm_get_exception : Intrinsic<[llvm_ptr_ty], [llvm_token_ty],
                                        [IntrHasSideEffects]>;
 def int_wasm_get_ehselector : Intrinsic<[llvm_i32_ty], [llvm_token_ty],
                                         [IntrHasSideEffects]>;
 // This is the same as llvm.wasm.get.exception except that it does not take a

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::donothing:
       break;
     case Intrinsic::experimental_patchpoint_void:
     case Intrinsic::experimental_patchpoint_i64:
       visitPatchpoint(&I, EHPadBB);
       break;
     case Intrinsic::experimental_gc_statepoint:
       LowerStatepoint(ImmutableStatepoint(&I), EHPadBB);
       break;
+    case Intrinsic::wasm_rethrow_in_catch: {
+      // This is usually done in visitTargetIntrinsic, but this intrinsic is
+      // special because it can be invoked, so we manually lower it to a DAG
+      // node here.
+      SmallVector<SDValue, 8> Ops;
+      Ops.push_back(getRoot()); // inchain
+      const TargetLowering &TLI = DAG.getTargetLoweringInfo();
+      Ops.push_back(
+          DAG.getTargetConstant(Intrinsic::wasm_rethrow_in_catch, getCurSDLoc(),
+                                TLI.getPointerTy(DAG.getDataLayout())));
+      SDVTList VTs = DAG.getVTList(ArrayRef<EVT>({MVT::Other})); // outchain
+      DAG.setRoot(DAG.getNode(ISD::INTRINSIC_VOID, getCurSDLoc(), VTs, Ops));
+      break;
+    }
     }
   } else if (I.countOperandBundlesOfType(LLVMContext::OB_deopt)) {
     // Currently we do not lower any intrinsic calls with deopt operand bundles.
     // Eventually we will support lowering the @llvm.experimental.deoptimize
     // intrinsic, and right now there are no plans to support other intrinsics
     // with deopt state.
     LowerCallSiteWithDeoptBundle(&I, getValue(Callee), EHPadBB);
   } else {

llvm/trunk/lib/CodeGen/WasmEHPrepare.cpp

class WasmEHPrepare : public FunctionPass {
   Type *LPadContextTy = nullptr; // type of 'struct _Unwind_LandingPadContext'
   GlobalVariable *LPadContextGV = nullptr; // __wasm_lpad_context
 
   // Field addresses of struct _Unwind_LandingPadContext
   Value *LPadIndexField = nullptr; // lpad_index field
   Value *LSDAField = nullptr;      // lsda field
   Value *SelectorField = nullptr;  // selector
 
-  Function *ThrowF = nullptr;           // wasm.throw() intrinsic
-  Function *RethrowF = nullptr;         // wasm.rethrow() intrinsic
-  Function *LPadIndexF = nullptr;       // wasm.landingpad.index() intrinsic
-  Function *LSDAF = nullptr;            // wasm.lsda() intrinsic
-  Function *GetExnF = nullptr;          // wasm.get.exception() intrinsic
-  Function *ExtractExnF = nullptr;      // wasm.extract.exception() intrinsic
-  Function *GetSelectorF = nullptr;     // wasm.get.ehselector() intrinsic
+  Function *ThrowF = nullptr;       // wasm.throw() intrinsic
+  Function *LPadIndexF = nullptr;   // wasm.landingpad.index() intrinsic
+  Function *LSDAF = nullptr;        // wasm.lsda() intrinsic
+  Function *GetExnF = nullptr;      // wasm.get.exception() intrinsic
+  Function *ExtractExnF = nullptr;  // wasm.extract.exception() intrinsic
+  Function *GetSelectorF = nullptr; // wasm.get.ehselector() intrinsic
   FunctionCallee CallPersonalityF =
-      nullptr;                          // _Unwind_CallPersonality() wrapper
+      nullptr; // _Unwind_CallPersonality() wrapper
 
   bool prepareEHPads(Function &F);
   bool prepareThrows(Function &F);
 
   void prepareEHPad(BasicBlock *BB, bool NeedLSDA, unsigned Index = 0);
   void prepareTerminateCleanupPad(BasicBlock *BB);
 
 public:

 
 bool WasmEHPrepare::prepareThrows(Function &F) {
   Module &M = *F.getParent();
   IRBuilder<> IRB(F.getContext());
   bool Changed = false;
 
   // wasm.throw() intinsic, which will be lowered to wasm 'throw' instruction.
   ThrowF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_throw);
-  // wasm.rethrow() intinsic, which will be lowered to wasm 'rethrow'
-  // instruction.
-  RethrowF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_rethrow);
-
-  // Insert an unreachable instruction after a call to @llvm.wasm.throw /
-  // @llvm.wasm.rethrow and delete all following instructions within the BB, and
-  // delete all the dead children of the BB as well.
-  for (auto L : {ThrowF->users(), RethrowF->users()}) {
-    for (User *U : L) {
-      // A call to @llvm.wasm.throw() is only generated from __cxa_throw()
-      // builtin call within libcxxabi, and cannot be an InvokeInst.
-      auto *ThrowI = cast<CallInst>(U);
-      if (ThrowI->getFunction() != &F)
-        continue;
-      Changed = true;
-      auto *BB = ThrowI->getParent();
-      SmallVector<BasicBlock *, 4> Succs(succ_begin(BB), succ_end(BB));
-      auto &InstList = BB->getInstList();
-      InstList.erase(std::next(BasicBlock::iterator(ThrowI)), InstList.end());
-      IRB.SetInsertPoint(BB);
-      IRB.CreateUnreachable();
-      eraseDeadBBsAndChildren(Succs);
-    }
-  }
+  // Insert an unreachable instruction after a call to @llvm.wasm.throw and
+  // delete all following instructions within the BB, and delete all the dead
+  // children of the BB as well.
+  for (User *U : ThrowF->users()) {
 
   return Changed;
 }
 
 bool WasmEHPrepare::prepareEHPads(Function &F) {
   Module &M = *F.getParent();
   IRBuilder<> IRB(F.getContext());
 

llvm/trunk/lib/IR/Verifier.cpp

if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
              "Cannot take the address of an intrinsic!", &I);
       Assert(
           !F->isIntrinsic() || isa<CallInst>(I) ||
               F->getIntrinsicID() == Intrinsic::donothing ||
               F->getIntrinsicID() == Intrinsic::coro_resume ||
               F->getIntrinsicID() == Intrinsic::coro_destroy ||
               F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void ||
               F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 ||
-              F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint,
+              F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint ||
+              F->getIntrinsicID() == Intrinsic::wasm_rethrow_in_catch,
           "Cannot invoke an intrinsic other than donothing, patchpoint, "
           "statepoint, coro_resume or coro_destroy",
           &I);
       Assert(F->getParent() == &M, "Referencing function in another module!",
              &I, &M, F, F->getParent());
     } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
       Assert(OpBB->getParent() == BB->getParent(),
              "Referring to a basic block in another function!", &I);

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrControl.td

 let Predicates = [HasExceptionHandling] in {
 
 // Throwing an exception: throw / rethrow
 let isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
 defm THROW : I<(outs), (ins event_op:$tag, variable_ops),
                (outs), (ins event_op:$tag),
                [(WebAssemblythrow (WebAssemblywrapper texternalsym:$tag))],
                "throw   \t$tag", "throw   \t$tag", 0x08>;
-defm RETHROW : NRI<(outs), (ins), [(int_wasm_rethrow)], "rethrow", 0x09>;
+defm RETHROW : I<(outs), (ins EXCEPT_REF:$exn), (outs), (ins),
+                 [], "rethrow \t$exn", "rethrow", 0x09>;
+// Pseudo instruction to be the lowering target of int_wasm_rethrow_in_catch
+// intrinsic. Will be converted to the real rethrow instruction later.
+let isPseudo = 1 in
+defm RETHROW_IN_CATCH : NRI<(outs), (ins), [(int_wasm_rethrow_in_catch)],
+                            "rethrow_in_catch", 0>;
 } // isTerminator = 1, hasCtrlDep = 1, isBarrier = 1
 
 // Region within which an exception is caught: try / end_try
 let Uses = [VALUE_STACK], Defs = [VALUE_STACK] in {
 defm TRY     : NRI<(outs), (ins Signature:$sig), [], "try     \t$sig", 0x06>;
 defm END_TRY : NRI<(outs), (ins), [], "end_try", 0x0b>;
 } // Uses = [VALUE_STACK], Defs = [VALUE_STACK]
 

llvm/trunk/lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

case WebAssembly::CATCHRET: {
       MachineBasicBlock *TBB = TI->getOperand(0).getMBB();
       if (!MBB.isLayoutSuccessor(TBB))
         BuildMI(MBB, TI, TI->getDebugLoc(), TII.get(WebAssembly::BR))
             .addMBB(TBB);
       TI->eraseFromParent();
       Changed = true;
       break;
     }
-    case WebAssembly::CLEANUPRET: {
-      // Replace a cleanupret with a rethrow
-      BuildMI(MBB, TI, TI->getDebugLoc(), TII.get(WebAssembly::RETHROW));
+    case WebAssembly::CLEANUPRET:
+    case WebAssembly::RETHROW_IN_CATCH: {
+      // Replace a cleanupret/rethrow_in_catch with a rethrow
+      auto *EHPad = getMatchingEHPad(TI);
+      auto CatchPos = EHPad->begin();
+      if (CatchPos->isEHLabel()) // EH pad starts with an EH label
+        ++CatchPos;
+      MachineInstr *Catch = &*CatchPos;
+      unsigned ExnReg = Catch->getOperand(0).getReg();
+      BuildMI(MBB, TI, TI->getDebugLoc(), TII.get(WebAssembly::RETHROW))
+          .addReg(ExnReg);
       TI->eraseFromParent();
       Changed = true;
       break;
     }
     }
   }
   return Changed;
 }
for (auto &MI : MBB) {
       // The instruction after the throw should be an unreachable or a branch to
       // another BB that should eventually lead to an unreachable. Delete it
       // because throw itself is a terminator, and also delete successors if
       // any.
       MBB.erase(std::next(MI.getIterator()), MBB.end());
       SmallVector<MachineBasicBlock *, 8> Succs(MBB.succ_begin(),
                                                 MBB.succ_end());
       for (auto *Succ : Succs)
+        if (!Succ->isEHPad())
           MBB.removeSuccessor(Succ);
       eraseDeadBBsAndChildren(Succs);
     }
   }
 
   return Changed;
 }
 
 // Wasm uses 'br_on_exn' instruction to check the tag of an exception. It takes
if (TerminatePads.count(EHPad)) {
       assert(ClangCallTerminateFn &&
              "There is no __clang_call_terminate() function");
       BuildMI(ElseMBB, DL, TII.get(WebAssembly::CALL_VOID))
           .addGlobalAddress(ClangCallTerminateFn)
           .addImm(0);
       BuildMI(ElseMBB, DL, TII.get(WebAssembly::UNREACHABLE));
 
     } else {
-      BuildMI(ElseMBB, DL, TII.get(WebAssembly::RETHROW));
+      BuildMI(ElseMBB, DL, TII.get(WebAssembly::RETHROW)).addReg(ExnReg);
       if (EHInfo->hasEHPadUnwindDest(EHPad))
         ElseMBB->addSuccessor(EHInfo->getEHPadUnwindDest(EHPad));
     }
   }
 
   return true;
 }
 

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

 ; CHECK:     br        1                               # 1: down to label0
 ; CHECK:   end_block                                   # label2:
 ; 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 label0
 ; CHECK:   end_block                                   # label3:
-; CHECK:   call      __cxa_rethrow
+; CHECK:   rethrow   {{.*}}                            # to caller
 ; CHECK: end_try                                       # label0:
 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.fallthrough:                                ; preds = %catch.start
   br i1 %matches1, label %catch, label %rethrow
 
 catch:                                            ; preds = %catch.fallthrough
   %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) ]
+  call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %1) ]
   unreachable
 
 try.cont:                                         ; preds = %entry, %catch, %catch2
   ret void
 }
 
 ; Nested try-catches within a catch
 ; void test1() {

 ; CHECK:           block
 ; CHECK:             br_if     0, {{.*}}               # 0: down to label11
 ; CHECK:             i32.call  $drop=, __cxa_begin_catch
 ; CHECK:             try
 ; CHECK:               call      foo
 ; CHECK:               br        2                     # 2: down to label9
 ; CHECK:             catch
 ; CHECK:               call      __cxa_end_catch
-; CHECK:               rethrow                         # down to catch3
+; CHECK:               rethrow   {{.*}}                # down to catch3
 ; CHECK:             end_try
 ; CHECK:           end_block                           # label11:
-; CHECK:           call      __cxa_rethrow
-; CHECK:           unreachable
+; CHECK:           rethrow   {{.*}}                    # down to catch3
 ; CHECK:         catch     {{.*}}                      # catch3:
 ; CHECK:           call      __cxa_end_catch
-; CHECK:           rethrow                             # to caller
+; CHECK:           rethrow   {{.*}}                    # to caller
 ; CHECK:         end_try                               # label9:
 ; CHECK:         call      __cxa_end_catch
 ; CHECK:         br        2                           # 2: down to label6
 ; CHECK:       end_try
 ; CHECK:     end_block                                 # label7:
-; CHECK:     call      __cxa_rethrow
-; CHECK:     unreachable
+; CHECK:     rethrow   {{.*}}                          # to caller
 ; CHECK:   end_block                                   # label6:
 ; 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
 
catch6:                                           ; preds = %catch.start3
   invoke void @foo() [ "funclet"(token %9) ]
           to label %invoke.cont8 unwind label %ehcleanup
 
 invoke.cont8:                                     ; preds = %catch6
   call void @__cxa_end_catch() [ "funclet"(token %9) ]
   catchret from %9 to label %try.cont
 
 rethrow5:                                         ; preds = %catch.start3
-  invoke void @__cxa_rethrow() [ "funclet"(token %9) ]
+  invoke void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %9) ]
           to label %unreachable unwind label %ehcleanup9
 
 try.cont:                                         ; preds = %catch, %invoke.cont8
   call void @__cxa_end_catch() [ "funclet"(token %1) ]
   catchret from %1 to label %try.cont11
 
 rethrow:                                          ; preds = %catch.start
-  call void @__cxa_rethrow() [ "funclet"(token %1) ]
+  call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %1) ]
   unreachable
 
 try.cont11:                                       ; preds = %entry, %try.cont
   ret void
 
 ehcleanup:                                        ; preds = %catch6
   %16 = cleanuppad within %9 []
   call void @__cxa_end_catch() [ "funclet"(token %16) ]

 ; CHECK:           br        2                         # 2: down to label16
 ; 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:           rethrow   {{.*}}                    # to caller
 ; CHECK:         end_try
 ; CHECK:       end_block                               # label17:
 ; CHECK:       call      __cxa_end_catch
 ; CHECK:       br        2                             # 2: down to label13
 ; CHECK:     end_block                                 # label16:
 ; CHECK:     br        0                               # 0: up to label15
 ; CHECK:   end_loop
 ; CHECK: end_try                                       # label13:
terminate:                                        ; preds = %ehcleanup
   unreachable
 }
 
 declare void @foo()
 declare void @bar()
 declare i32 @__gxx_wasm_personality_v0(...)
 declare i8* @llvm.wasm.get.exception(token)
 declare i32 @llvm.wasm.get.ehselector(token)
+declare void @llvm.wasm.rethrow.in.catch()
 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 void @_ZSt9terminatev()

llvm/trunk/test/CodeGen/WebAssembly/exception.ll

 ; CHECK-LABEL: test_throw:
 ; 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
-define void @test_rethrow(i8* %p) {
-  call void @llvm.wasm.rethrow()
-  ret void
-}
-
 ; 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:     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:         rethrow   $[[EXCEPT_REF]]
 ; 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:       rethrow   $[[EXCEPT_REF]]
 ; CHECK:     end_try
 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
   %1 = catchpad within %0 [i8* bitcast (i8** @_ZTIi 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 %catch, label %rethrow
 
 catch:                                            ; preds = %catch.start
   %5 = 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.start
-  call void @__cxa_rethrow() [ "funclet"(token %1) ]
+  call void @llvm.wasm.rethrow.in.catch() [ "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: try
 ; CHECK:   call      foo
-; CHECK: catch
+; CHECK: catch     $[[EXCEPT_REF:[0-9]+]]=
 ; CHECK:   global.set  __stack_pointer
 ; CHECK:   i32.call  $drop=, _ZN4TempD2Ev
-; CHECK:   rethrow
+; CHECK:   rethrow   $[[EXCEPT_REF]]
 ; CHECK: end_try
 define void @test_cleanup() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
 entry:
   %t = alloca %struct.Temp, align 1
   invoke void @foo()
           to label %invoke.cont unwind label %ehcleanup
 
 invoke.cont:                                      ; preds = %entry

 ; 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:         rethrow
 ; CHECK:       end_block
 ; CHECK-NOT:   global.set  __stack_pointer, $pop{{.+}}
 ; CHECK:       call      __cxa_end_catch
 ; CHECK:     end_try
 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)
catch:                                            ; preds = %catch.start
   invoke void @foo() [ "funclet"(token %1) ]
           to label %invoke.cont1 unwind label %ehcleanup
 
 invoke.cont1:                                     ; preds = %catch
   call void @__cxa_end_catch() [ "funclet"(token %1) ]
   catchret from %1 to label %try.cont
 
 rethrow:                                          ; preds = %catch.start
-  call void @__cxa_rethrow() [ "funclet"(token %1) ]
+  call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %1) ]
   unreachable
 
 try.cont:                                         ; preds = %entry, %invoke.cont1
   ret void
 
 ehcleanup:                                        ; preds = %catch
   %8 = cleanuppad within %1 []
   call void @__cxa_end_catch() [ "funclet"(token %8) ]

 try.cont:                                         ; preds = %entry, %catch.start
   ret void
 }
 
 declare void @foo()
 declare void @bar(i32*)
 declare i32 @__gxx_wasm_personality_v0(...)
 declare void @llvm.wasm.throw(i32, i8*)
-declare void @llvm.wasm.rethrow()
 declare i8* @llvm.wasm.get.exception(token)
 declare i32 @llvm.wasm.get.ehselector(token)
+declare void @llvm.wasm.rethrow.in.catch()
 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.Temp* @_ZN4TempD2Ev(%struct.Temp* returned)
 
 ; CHECK: __cpp_exception:
 ; CHECK: .eventtype  __cpp_exception i32

llvm/trunk/test/CodeGen/WebAssembly/wasmehprepare.ll

 catch:                                            ; preds = %catch.start
   %5 = 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
 ; CHECK: catch:
 ; CHECK-NEXT:  call i8* @__cxa_begin_catch(i8* %[[EXN]])
 
 rethrow:                                          ; preds = %catch.start
-  call void @__cxa_rethrow() [ "funclet"(token %1) ]
+  call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %1) ]
   unreachable
 
 try.cont:                                         ; preds = %entry, %catch
   ret void
 }
 
 ; Two try-catches.
 ; For the catchpad with a single 'catch (...)', only a wasm.catch() call should

 ; CHECK:   call void @llvm.wasm.landingpad.index(token %{{.+}}, i32 0)
 
 catch4:                                           ; preds = %catch.start3
   %10 = call i8* @__cxa_begin_catch(i8* %7) [ "funclet"(token %6) ]
   call void @__cxa_end_catch() [ "funclet"(token %6) ]
   catchret from %6 to label %try.cont7
 
 rethrow:                                          ; preds = %catch.start3
-  call void @__cxa_rethrow() [ "funclet"(token %6) ]
+  call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %6) ]
   unreachable
 
 try.cont7:                                        ; preds = %try.cont, %catch4
   ret void
 }
 
 ; A nested try-catch within a catch.
 ;

 ; CHECK-NOT:   call i8* @llvm.wasm.lsda()
 
 catch6:                                           ; preds = %catch.start3
   %11 = call i8* @__cxa_begin_catch(i8* %8) [ "funclet"(token %7) ]
   call void @__cxa_end_catch() [ "funclet"(token %7) ]
   catchret from %7 to label %try.cont
 
 rethrow5:                                         ; preds = %catch.start3
-  invoke void @__cxa_rethrow() [ "funclet"(token %7) ]
+  invoke void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %7) ]
           to label %unreachable unwind label %ehcleanup
 
 try.cont:                                         ; preds = %catch, %catch6
   call void @__cxa_end_catch() [ "funclet"(token %1) ]
   catchret from %1 to label %try.cont9
 
 rethrow:                                          ; preds = %catch.start
-  call void @__cxa_rethrow() [ "funclet"(token %1) ]
+  call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %1) ]
   unreachable
 
 try.cont9:                                        ; preds = %entry, %try.cont
   ret void
 
 ehcleanup:                                        ; preds = %rethrow5, %catch.dispatch2
   %12 = cleanuppad within %1 []
   call void @__cxa_end_catch() [ "funclet"(token %12) ]

 bb.false:                                         ; preds = %entry
   br label %merge
 
 ; CHECK:      merge
 merge:                                            ; preds = %bb.true.0, %bb.false
   ret i32 0
 }
 
-; Tests if instructions after a call to @llvm.wasm.rethrow are deleted and the
-; BB's dead children are deleted.
-
-; CHECK-LABEL: @test6
-define i32 @test6(i1 %b, i8* %p) {
-entry:
-  br i1 %b, label %bb.true, label %bb.false
-
-; CHECK:      bb.true:
-; CHECK-NEXT:   call void @llvm.wasm.rethrow()
-; CHECK-NEXT:   unreachable
-bb.true:                                          ; preds = %entry
-  call void @llvm.wasm.rethrow()
-  br label %bb.true.0
-
-; CHECK-NOT:  bb.true.0
-bb.true.0:                                        ; preds = %bb.true
-  br label %merge
-
-; CHECK:      bb.false
-bb.false:                                         ; preds = %entry
-  br label %merge
-
-; CHECK:      merge
-merge:                                            ; preds = %bb.true.0, %bb.false
-  ret i32 0
-}
-
 declare void @foo()
 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 void @llvm.wasm.rethrow.in.catch()
 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*)