[WebAssembly] Rename wasm.catch.exn intrinsic back to wasm.catch

[aheejin]

Summary

The plan was to use wasm.catch.exn intrinsic to catch exceptions and
add wasm.catch.longjmp intrinsic, that returns two values (setjmp
buffer and return value), later to catch longjmps. But because we
decided not to use multivalue support at the moment, we are going to use
one intrinsic that returns a single value for both exceptions and
longjmps. And even if it's not for that, I now think the naming of
wasm.catch.exn is a little weird, because the intrinsic can still take
a tag immediate, which means it can be used for anything, not only
exceptions, as long as that returns a single value.

This partially reverts D107405.

[tlively]

Is there a comment thread about using multivalue or not that I can catch up on?

[aheejin]

Oh no it's more like not we but I've decided not to use it.. 😅 Sorry for not being clear. Yeah apparently the LLVM codegen for multivalue and Binaryen DWARF support are not stable, and I don't want to delay Wasm SjLj after fixing all those issues, and the workaround is simple enough, so I thought why not.

llvm/include/llvm/IR/IntrinsicsWebAssembly.td

 
 // 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]>;
 
-// wasm.catch.exn returns the pointer to the exception object caught by wasm
-// 'catch' instruction. This returns a single pointer, which is the case for C++
+// wasm.catch returns the pointer to the exception object caught by wasm 'catch'
+// instruction. This returns a single pointer, which is the case for C++
 // exceptions. The immediate argument is an index to for a tag, which is 0 for
 // C++ exceptions.
-def int_wasm_catch_exn : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty],
-                                   [IntrHasSideEffects, ImmArg<ArgIndex<0>>]>;
+def int_wasm_catch : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty],
 
 // WebAssembly EH must maintain the landingpads in the order assigned to them
 // by WasmEHPrepare pass to generate landingpad table in EHStreamer. This is
 // used in order to give them the indices in WasmEHPrepare.
 def int_wasm_landingpad_index: Intrinsic<[], [llvm_token_ty, llvm_i32_ty],
                                          [IntrNoMem, ImmArg<ArgIndex<1>>]>;
 
 // Returns LSDA address of the current function.

llvm/lib/CodeGen/WasmEHPrepare.cpp

 // - Before:
 //   catchpad ...
 //   exn = wasm.get.exception();
 //   selector = wasm.get.selector();
 //   ...
 //
 // - After:
 //   catchpad ...
-//   exn = wasm.catch.exn(WebAssembly::CPP_EXCEPTION);
+//   exn = wasm.catch(WebAssembly::CPP_EXCEPTION);
 //   // Only add below in case it's not a single catch (...)
 //   wasm.landingpad.index(index);
 //   __wasm_lpad_context.lpad_index = index;
 //   __wasm_lpad_context.lsda = wasm.lsda();
 //   _Unwind_CallPersonality(exn);
 //   selector = __wasm.landingpad_context.selector;
 //   ...
 //
class WasmEHPrepare : public FunctionPass {
   Value *LPadIndexField = nullptr; // lpad_index field
   Value *LSDAField = nullptr;      // lsda field
   Value *SelectorField = nullptr;  // selector
 
   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 *CatchF = nullptr;       // wasm.catch.exn() intrinsic
+  Function *CatchF = nullptr;       // wasm.catch() intrinsic
   Function *GetSelectorF = nullptr; // wasm.get.ehselector() intrinsic
   FunctionCallee CallPersonalityF =
       nullptr; // _Unwind_CallPersonality() wrapper
 
   bool prepareThrows(Function &F);
   bool prepareEHPads(Function &F);
   void prepareEHPad(BasicBlock *BB, bool NeedPersonality, unsigned Index = 0);
 
bool WasmEHPrepare::prepareEHPads(Function &F) {
   // wasm.lsda() intrinsic. Returns the address of LSDA table for the current
   // function.
   LSDAF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_lsda);
   // wasm.get.exception() and wasm.get.ehselector() intrinsics. Calls to these
   // are generated in clang.
   GetExnF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_get_exception);
   GetSelectorF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_get_ehselector);
 
-  // wasm.catch.exn() will be lowered down to wasm 'catch' instruction in
+  // wasm.catch() will be lowered down to wasm 'catch' instruction in
   // instruction selection.
-  CatchF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_catch_exn);
+  CatchF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_catch);
 
   // _Unwind_CallPersonality() wrapper function, which calls the personality
   CallPersonalityF = M.getOrInsertFunction(
       "_Unwind_CallPersonality", IRB.getInt32Ty(), IRB.getInt8PtrTy());
   if (Function *F = dyn_cast<Function>(CallPersonalityF.getCallee()))
     F->setDoesNotThrow();
 
   unsigned Index = 0;
void WasmEHPrepare::prepareEHPad(BasicBlock *BB, bool NeedPersonality,
   // Cleanup pads do not have any of wasm.get.exception() or
   // wasm.get.ehselector() calls. We need to do nothing.
   if (!GetExnCI) {
     assert(!GetSelectorCI &&
            "wasm.get.ehselector() cannot exist w/o wasm.get.exception()");
     return;
   }
 
-  // Replace wasm.get.exception intrinsic with wasm.catch.exn intrinsic, which
-  // will be lowered to wasm 'catch' instruction. We do this mainly because
+  // Replace wasm.get.exception intrinsic with wasm.catch intrinsic, which will
+  // be lowered to wasm 'catch' instruction. We do this mainly because
   // instruction selection cannot handle wasm.get.exception intrinsic's token
   // argument.
   Instruction *CatchCI =
       IRB.CreateCall(CatchF, {IRB.getInt32(WebAssembly::CPP_EXCEPTION)}, "exn");
   GetExnCI->replaceAllUsesWith(CatchCI);
   GetExnCI->eraseFromParent();
 
   // In case it is a catchpad with single catch (...) or a cleanuppad, we don't

llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp

case Intrinsic::wasm_tls_base: {
       MachineSDNode *TLSBase = CurDAG->getMachineNode(
           GlobalGetIns, DL, PtrVT, MVT::Other,
           CurDAG->getTargetExternalSymbol("__tls_base", PtrVT),
           Node->getOperand(0));
       ReplaceNode(Node, TLSBase);
       return;
     }
 
-    case Intrinsic::wasm_catch_exn: {
+    case Intrinsic::wasm_catch: {
       int Tag = Node->getConstantOperandVal(2);
       SDValue SymNode = getTagSymNode(Tag, CurDAG);
       MachineSDNode *Catch =
           CurDAG->getMachineNode(WebAssembly::CATCH, DL,
                                  {
                                      PtrVT,     // exception pointer
                                      MVT::Other // outchain type
                                  },

llvm/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.Temp = type { i8 }
 
 ; A single 'catch (int)' clause.
-; A wasm.catch.exn() call, wasm.lsda() call, and personality call to generate a
+; 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) {
 ;   }
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
 ; CHECK: catch.start:
 ; CHECK-NEXT:   %[[CATCHPAD:.*]] = catchpad
-; CHECK-NEXT:   %[[EXN:.*]] = call i8* @llvm.wasm.catch.exn(i32 0)
+; CHECK-NEXT:   %[[EXN:.*]] = call i8* @llvm.wasm.catch(i32 0)
 ; CHECK-NEXT:   call void @llvm.wasm.landingpad.index(token %[[CATCHPAD]], i32 0)
 ; CHECK-NEXT:   store i32 0, i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 0)
 ; CHECK-NEXT:   %[[LSDA:.*]] = call i8* @llvm.wasm.lsda()
 ; CHECK-NEXT:   store i8* %[[LSDA]], i8** getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 1)
 ; CHECK-NEXT:   call i32 @_Unwind_CallPersonality(i8* %[[EXN]]) {{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
 ; CHECK-NEXT:   %[[SELECTOR:.*]] = load i32, i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 2)
 ; CHECK:   icmp eq i32 %[[SELECTOR]]
 
 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 @llvm.wasm.rethrow() [ "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.exn() 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.
+; 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 {