[WebAssembly] Rename Emscripten EH functions

[aheejin]

Summary

[WebAssembly] Rename Emscripten EH functions

Renaming for some Emscripten EH functions has so far been done in
wasm-emscripten-finalize tool in Binaryen. But recently we decided to
make a compilation/linking path that does not rely on
wasm-emscripten-finalize for modifications, so here we move that
functionality to LLVM.

Invoke wrappers are generated in LowerEmscriptenEHSjLj pass, but final
wasm types are not available in the IR pass, we need to rename them at
the end of the pipeline.

This patch also removes uses of emscripten_longjmp_jmpbuf in
LowerEmscriptenEHSjLj pass, replacing that with emscripten_longjmp.
emscripten_longjmp_jmpbuf is lowered to emscripten_longjmp, but
previously we generated calls to emscripten_longjmp_jmpbuf in
LowerEmscriptenEHSjLj pass because it takes jmp_buf* instead of i32.
But we were able use ptrtoint to make it use emscripten_longjmp
directly here.

Addresses:
https://github.com/WebAssembly/binaryen/issues/3043
https://github.com/WebAssembly/binaryen/issues/3081

Companions:
https://github.com/WebAssembly/binaryen/pull/3191
https://github.com/emscripten-core/emscripten/pull/12399

[aheejin]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

118

This comment doesn't sound relevant now. This was added in D52580 by @dschuff, and then the line below this comment was this:

getTargetStreamer()->emitIndirectFunctionType(Sym);

I don't know the full history, but the comment seemed to be somehow related to indirect function types, but it seems we are using this for all functions types, so we don't need this FIXME anymore..?

121

I guess now isOSBinFormatWasm() is always true? So removed it

[aheejin]

• Update test expectations

[dschuff]

So, just to be sure I understand the architecture here:
Previously we use separate longjup_jmpbuf/longjmp and __invoke_{$LLVMSIG} because the lowering pass runs on IR and the IR type system's rules apply (and we don't have wasm signatures there). Now we can get wasm function signatures at AsmPrinter::emitEndOfAsmFile and the only thing that needs to be done is rename them?

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

118

In the meantime @aardappel did rethink how import declarations work in asm files (and that's why we got the .functype directive in https://reviews.llvm.org/D54652). And he also fixed the huge pile of tests that this comment refers to. so removing this FIXME LGTM.

121

LGTM, we don't support wasm-in-ELF anymore.

155

I don' think this check is necessary, empty params just won't trip the loop.

226

I think you can just call insert unconditionally and ignore its return value in this case.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

65

this isn't an override, right? should it go after the functions that are part of the AsmPrinter implementation?

[aheejin]

• Comment fix

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

151–152

This naming scheme does not support multivalue functions. For example functions with signatures (i32) -> (i32, i32) and (i32, i32) -> (i32) both become invoke_iii and are indistinguishable. Would it make sense to error out if Sig->Returns has multiple elements?

213–231

"have created" => "have been created"

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

52

Should this be a non-dyn cast now?

[aheejin]

In D88697#2307516, @dschuff wrote:

So, just to be sure I understand the architecture here:
Previously we use separate longjup_jmpbuf/longjmp and __invoke_{$LLVMSIG} because the lowering pass runs on IR and the IR type system's rules apply (and we don't have wasm signatures there). Now we can get wasm function signatures at AsmPrinter::emitEndOfAsmFile and the only thing that needs to be done is rename them?

Yes. For invokes the problem is, as you pointed out, we don't have final signatures there. For emscripten_longjmp_jmpbuf / emscripten_longjmp, the problem is not that we don't have the final signature there, but rather, we cannot have two functions with different signatures with the same name emscripten_longjmp. There are two occasions that we add a call to emscripten_longjmp, but one of them is calling it with an argument type jmp_buf. So we need two different signatures, and thus two different functions there. But jmp_buf is lowered to i32 at this point so we can unify them.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

151–152

I thought about this and initially tried to separate returns and params with _, but didn't end up doing it because

1. I'm not even sure if Emscripten EH supports multiple returns now.
2. Even if it does (or it will in future), I think making it a separate patch is better, because changing this will change the invoke interface currently shared with Emscripten.

Yeah, in the meantime, I think erroring out when people try to use multivalue functions with Emscripten EH/SjLj sounds like a good idea. Added the error message, and added 'lower-em-ehsjlj-multi-return.ll' to check this erroring out behavior.

226

We still need to continue in case the symbol is already in the map. I changed the code to this. This does not ignore the return value but uses it to figure out whether we should continue or not. Did you mean this?

if (!EmSymbols.insert(Sym).second)                                       
  continue;

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

65

It is used by emitEndOfAsmFile so I put it there, but yeah, I think moving its declaration down is better. It is still placed right before in emitEndOfAsmFile in cpp file; let me know if you think we should change that too.

[aheejin]

• Address comments

[tlively]

There are two occasions that we add a call to emscripten_longjmp, but one of them is calling it with an argument type jmp_buf. So we need two different signatures, and thus two different functions there.

Would it also work to emit a bitcast of some sort from jmp_buf to i32 where that second kind of emscripten_longjmp call is generated? If so, would that be simpler overall?

[dschuff]

LGTM modulo Thomas's idea if you think that will work and is an improvement.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

65

Oh, I think WebAssemblyAsmPrinter (the class and the .cpp file) is the right place to put it, I just meant that the comment says "AsmPrinter Implementation" which I took to mean "these functions are overrides of the AsmPrinter class's virtual functions". so getMCSymbolForFunction can just go after those rather than in between the comment and the AsmPrinter overrides. What you have now is fine.

[aheejin]

In D88697#2307808, @tlively wrote:

There are two occasions that we add a call to emscripten_longjmp, but one of them is calling it with an argument type jmp_buf. So we need two different signatures, and thus two different functions there.

Would it also work to emit a bitcast of some sort from jmp_buf to i32 where that second kind of emscripten_longjmp call is generated? If so, would that be simpler overall?

That's a good idea! bitcast doesn't work here, but I was able to use ptrtoint. Yeah, it looks simpler, and we only need to rename invokes at the end. Changed LowerEmscriptenEHSjLj pass to do that and deleted all jmp_buf related stuff.

[aheejin]

Use emscripten_longjmp directly in LowerEmscriptenEHSjLj pass

[aheejin]

• Revert accidental .clang-tidy change + variable renaming

[aheejin]

llvm/test/CodeGen/WebAssembly/lower-em-ehsjlj-multi-return.ll

1 ↗

(On Diff #295890)

This file shows diff from lower-em-ehsjlj-options.ll so it looks weird, but this is actually a new file (copied from lower-em-ehsjlj-options.ll just to quickly create a test file) and this file checks the erroring-out behavior for multivalue returns.

[aheejin]

• more comment

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

647–648

Do we emit an error if EmscriptenEHSjLj is used with wasm64?

[sbc100]

In PR description: final wasm times -> but final wasm types

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

226

What happens here if there is a user symbol that starts with invoke_? Perhaps getMCSymbolForFunction could also return bool if it detected an __invoke_ wrapper?

Might be worth adding a function called invoke_ignoreme as a normal symbol in one of the tests?

253–255

Again, this check seem fragile or at least maybe worthy of a helper like isEmscriptenInvokeWrapperName?

[aheejin]

• Error out for wasm64

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

226

What happens here if there is a user symbol that starts with invoke_?

We haven't handled this situation so far, and this patch does not change this. Invokes' format has set in Emscripten, so any user code that uses function name starting with invoke_ has a problem now. I think we should consider prepending Emscripten's invokes with two underscores as in the names generated by LowerEmscriptenEHSjLj pass, given that functions with two leading underscores are mostly considered compiler-specific functions. But I'd like to do it as a separate patch, as that changes the interface between LLVM, Binaryen, and Emscripten. Do you think this is a good idea?

Perhaps getMCSymbolForFunction could also return bool if it detected an __invoke_ wrapper?

What will it be used for?

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

647–648

No. Supporting wasm64 in Emscripten EHSjLj will be a simple task, but I guess no one needs it now and supporting it should be a separate CL. Erroring out sounds good to me for an interim measure. Did that.

The condition here is little tricky: Emscripten always enables SjLj, so we can't error out whenever SjLj is enabled. But we can check by whether setjmp or longjmp is actually used, so we error out only when one of those are used.
Whether we really use EH is hard to check unless we scan every single instruction in all functions. Anyway Emscripten EH is not enabled by default, so we error out whenever EH is enabled. (EH does not use emscripten_longjmp, but apparently other global variables used in this pass also needs adjusting to i64, which is not hard if we need to do that)

[aheejin]

Revise invoke format

[aheejin]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

226

I ended up renaming invokes to use two leading underscores in this patch. I wanted to it as a separate patch, but that will again need three different patches each from LLVM, Binaryen, and Emscripten, and landing it through the roller using a double roll twice is also a pain, so I ended up doing it here. Will do the same for the pending Binaryen and Emscripten paches.

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

226

I was actually thinking of the case where there a *not* a collision.

e.g. invoke_foo

This cannot possibly collide today because foo is not a valid signature. The code today seems to allow this and pass through such symbols. wasm-emscripten-finalize includes this function in the normal exports section not in the invokeFuncs section of the metadata.

By renaming the functions to use two underscores we solve this issue but I still think it might be nicer for getMCSymbolForFunction to return an additional bool if it created a wrapper.. rather then trying to detect this post-hoc with a call to isEmscriptenInvokeWrapperName on the result.

[aheejin]

Sorry for changing things again; I reverted the invoke format changing part (two leading underscore thing). Renaming this turns out to change a lot of things in Emscripten side, which I think is really better be a separate patch.

[aheejin]

• Add invoke_ignoreme test

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

226

I added invoke_ignoreme test. This test passes without a problem in the current code.

Adding InvokeDetected output parameter to getMCSymbolForFunction seems tricky. getMCSymbolForFunction can either create a new invoke symbol or retrieve an existing invoke symbol.

Note that this function is used in two different places. When used in MCInstLower, it always creates a symbol. But when used in AsmPrinter, it can either create a symbol or retrieve an existing symbol. (It creates a symbol in AsmPrinter when the symbol has not been used in any instructions, such as calls, so it didn't have a chance to be created in MCInstLower.)

So when retrieving an already created invoke symbol, getMCSymbolForFunction just returns the existing name, so it cannot distinguish invoke_vi from invoke_foo. So if we only count newly created invoke symbols, we are gonna miss already created invoke symbols in calls from emitEndOfAsmFile in AsmPrinter.

But I'm not sure if this is a problem. Without this we can use invoke_ignoreme just fine. It will be put into EmSymbols set under the incorrect assumption that it is an invoke symbol, but that does not cause any problem here. We can actually put all symbols in the set; I didn't do that because I didn't want to grow a large set every time.

[aheejin]

• EmSymbols -> InvokeSymbols

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

226

I think I still don't really understand.. isn't this condition basically trying to say saying "is this a symbol that possibly got remapped by getMCSymbolForFunction"?

if that is true then the more precise condition would be the same as the one in line of getMCSymbolForFunction wouldn't it: if (EnableEmEH && isEmscriptenInvokeWrapperName(F->getName())) ?

It seems like this line is trying to infer this condition based on the name of the resulting MC symbol.

But as you say maybe it doesn't matter if this condition is conservative?

227

Perhaps merge these two lines into single condition.

[aheejin]

• Add InvokeDetected output param to getMCSymbolForFunction
• Rename InvokeWrapper to just Invoke

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

226

Oh you're right. I was confused and forgot that getMCSymbolForFunction uses and always has an access to the original function name. Nevermind what I said ;( Changed getMCSymbolForFunction to take an additional output parameter InvokeDetected and made the caller to use it.

[aheejin]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

253–255

Sorry I missed this. Now this is using InvokeDetected as well, so I think it's OK now.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

bool runOnMachineFunction(MachineFunction &MF) override {
     MFI = MF.getInfo<WebAssemblyFunctionInfo>();
     return AsmPrinter::runOnMachineFunction(MF);
   }
 
   //===------------------------------------------------------------------===//
   // AsmPrinter Implementation.
   //===------------------------------------------------------------------===//
 
+  MCSymbolWasm *getMCSymbolForFunction(const Function *F, bool EnableEmEH,
+                                       wasm::WasmSignature *Sig);
   void emitEndOfAsmFile(Module &M) override;
   void EmitProducerInfo(Module &M);
   void EmitTargetFeatures(Module &M);
   void emitJumpTableInfo() override;
   void emitConstantPool() override;
   void emitFunctionBodyStart() override;
   void emitInstruction(const MachineInstr *MI) override;
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
 extern cl::opt<bool> WasmKeepRegisters;
+extern cl::opt<bool> EnableEmException;
+extern cl::opt<bool> EnableEmSjLj;
 
 //===----------------------------------------------------------------------===//
 // Helpers.
 //===----------------------------------------------------------------------===//
 
 MVT WebAssemblyAsmPrinter::getRegType(unsigned RegNo) const {
   const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
   const TargetRegisterClass *TRC = MRI->getRegClass(RegNo);
std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) {
   return '$' + utostr(WAReg);
 }
 
 WebAssemblyTargetStreamer *WebAssemblyAsmPrinter::getTargetStreamer() {
   MCTargetStreamer *TS = OutStreamer->getTargetStreamer();
   return static_cast<WebAssemblyTargetStreamer *>(TS);
 }
 
+// Emscripten exception handling helpers
+//
+// We need to fix two things here:
+//
+// 1. Change emscripten_longjmp_jmpbuf function to emscripten_longjmp.
+//    What we try to do in LowerEmscriptenEHSjLj pass is to change all function
+//    calls to longjmp to calls to emscripten_longjmp. Because we replace all
+//    calls to longjmp to emscripten_longjmp, the signature of that function
+//    should be the same as longjmp: emscripten_longjmp(jmp_buf, int) But after
+//    calling a function that might longjmp, while we test whether a longjmp
+//    occurred, we have to load an int address value and call emscripten_longjmp
+//    again with that address as the first argument. In this case we need the
+//    signature of emscripten_longjmp to be (int, int). We have to give them
+//    different names in the LLVM IR pass because they have different
+//    signatures, but after instruction selection they are lowered to the same
+//    signature, so we unify those names here.
+//
+// 2. Converts invoke wrapper names generated by LowerEmscriptenEHSjLj to real
+//    wrapper names that are expected by JavaScript glue code.
+//    The invoke wrapper names generated by Emscripten JS glue code are based on
+//    their argument and return types; for example, for a function that takes an
+//    i32 and returns nothing, it is 'invoke_vi'. But the format of invoke
+//    wrapper generated by LowerEmscriptenEHSjLj pass contains a mangled string
+//    generated from their IR types, for example,
+//    "__invoke_void_%struct.mystruct*_int", because final wasm types are not
+//    available in the IR pass. So we convert those names to the form that
+//    Emscripten JS code expects.
+//
+// Refer to LowerEmscriptenEHSjLj pass for more details.
+
+// Returns true if the given function name is an invoke wrapper name generated
+// by LowerEmscriptenEHSjLj pass.
+static bool isEmscriptenInvokeWrapperName(StringRef Name) {
+  if (Name.front() == '"' && Name.back() == '"')
+    Name = Name.substr(1, Name.size() - 2);
+  return Name.startswith("__invoke_");
+}
+
+// Returns a character that represents the given wasm value type in invoke
+// wrapper strings.
+static char getInvokeWrapperSig(wasm::ValType VT) {
+  switch (VT) {
+  case wasm::ValType::I32:
+    return 'i';
+  case wasm::ValType::I64:
+    return 'j';
+  case wasm::ValType::F32:
+    return 'f';
+  case wasm::ValType::F64:
+    return 'd';
+  case wasm::ValType::V128:
+    return 'V';
+  case wasm::ValType::EXNREF:
+    return 'E';
+  case wasm::ValType::EXTERNREF:
+    return 'X';
+  }
+}
+
+// Given the wasm signature, generate the invoke wrapper name in the format JS
+// glue code expects.
+static std::string
+getEmscriptenInvokeWrapperSymbolName(wasm::WasmSignature *Sig) {
+  std::string Ret = "invoke_";
+  if (!Sig->Returns.empty())
+    for (auto VT : Sig->Returns)
+      Ret += getInvokeWrapperSig(VT);
+  else
+    Ret += 'v';
+  if (!Sig->Params.empty()) {
+    // Invoke wrappers' first argument is a pointer to the original function, so
+    // skip it
+    for (unsigned I = 1, E = Sig->Params.size(); I < E; I++)
+      Ret += getInvokeWrapperSig(Sig->Params[I]);
+  }
+  return Ret;
+}
+
+// Returns true if the given symbol name is one of the specially converted
+// Emscripten EH / SjLj related names. Note that these are converted final
+// symbol names and not the original names generated fom LowerEmscripten EHSjLj
+// pass. These include:
+// - Invoke wrapper symbol names
+// - "emscripten_longjmp"
+static bool isEmscriptenEHSymbolName(StringRef Name) {
+  return Name.startswith("invoke_") || Name == "emscripten_longjmp";
+}
+
 //===----------------------------------------------------------------------===//
 // WebAssemblyAsmPrinter Implementation.
 //===----------------------------------------------------------------------===//
 
+MCSymbolWasm *WebAssemblyAsmPrinter::getMCSymbolForFunction(
+    const Function *F, bool EnableEmEH, wasm::WasmSignature *Sig) {
+  MCSymbolWasm *WasmSym = nullptr;
+  if (EnableEmEH && F->getName() == "emscripten_longjmp_jmpbuf") {
+    WasmSym = cast<MCSymbolWasm>(GetExternalSymbolSymbol("emscripten_longjmp"));
+  } else if (EnableEmEH && isEmscriptenInvokeWrapperName(F->getName())) {
+    assert(Sig);
+    WasmSym = cast<MCSymbolWasm>(
+        GetExternalSymbolSymbol(getEmscriptenInvokeWrapperSymbolName(Sig)));
+  } else {
+    WasmSym = cast<MCSymbolWasm>(getSymbol(F));
+  }
+  return WasmSym;
+}
+
 void WebAssemblyAsmPrinter::emitEndOfAsmFile(Module &M) {
   for (auto &It : OutContext.getSymbols()) {
     // Emit a .globaltype and .eventtype declaration.
     auto Sym = cast<MCSymbolWasm>(It.getValue());
     if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_GLOBAL)
       getTargetStreamer()->emitGlobalType(Sym);
     else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_EVENT)
       getTargetStreamer()->emitEventType(Sym);
   }
 
+  DenseSet<MCSymbol *> EmSymbols;
   for (const auto &F : M) {
     if (F.isIntrinsic())
       continue;
 
     // Emit function type info for all undefined functions
     if (F.isDeclarationForLinker()) {
       SmallVector<MVT, 4> Results;
       SmallVector<MVT, 4> Params;
       computeSignatureVTs(F.getFunctionType(), &F, F, TM, Params, Results);
-      auto *Sym = cast<MCSymbolWasm>(getSymbol(&F));
+      // At this point these MCSymbols may or may not have been created already
+      // and thus also contain a signature, but we need to get the signature
+      // anyway here in case it is an Emscripten EH wrapper that has not yet
+      // been created. We will discard it later if it turns out not to be
+      // necessary.
+      auto Signature = signatureFromMVTs(Results, Params);
+      auto *Sym = getMCSymbolForFunction(&F, EnableEmException || EnableEmSjLj,
+                                         Signature.get());
+
+      // Multiple functions can be mapped to the same invoke wrapper symbol. For
+      // example, two IR functions '__invoke_void_i8*' and '__invoke_void_i32'
+      // are both mapped to '__invoke_vi'. We keep them in a set once we emit an
+      // Emscripten EH symbol so we don't emit the same symbol twice.
+      if (isEmscriptenEHSymbolName(Sym->getName())) {
+        if (EmSymbols.count(Sym))
+          continue;
+        EmSymbols.insert(Sym);
+      }
+
       Sym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       if (!Sym->getSignature()) {
-        auto Signature = signatureFromMVTs(Results, Params);
         Sym->setSignature(Signature.get());
         addSignature(std::move(Signature));
+      } else {
+        // This symbol has already been created and had a signature. Discard it.
+        Signature.release();
       }
-      // FIXME: this was originally intended for post-linking and was only used
-      // for imports that were only called indirectly (i.e. s2wasm could not
-      // infer the type from a call). With object files it applies to all
-      // imports. so fix the names and the tests, or rethink how import
-      // delcarations work in asm files.
+
       getTargetStreamer()->emitFunctionType(Sym);
 
-      if (TM.getTargetTriple().isOSBinFormatWasm() &&
-          F.hasFnAttribute("wasm-import-module")) {
+      if (F.hasFnAttribute("wasm-import-module")) {
         StringRef Name =
             F.getFnAttribute("wasm-import-module").getValueAsString();
         Sym->setImportModule(storeName(Name));
         getTargetStreamer()->emitImportModule(Sym, Name);
       }
-      if (TM.getTargetTriple().isOSBinFormatWasm() &&
-          F.hasFnAttribute("wasm-import-name")) {
+      if (F.hasFnAttribute("wasm-import-name")) {
+        // If this is a converted Emscripten EH/SjLj symbol, we shouldn't use
+        // the original function name but the converted symbol name.
         StringRef Name =
-            F.getFnAttribute("wasm-import-name").getValueAsString();
+            isEmscriptenEHSymbolName(Sym->getName())
+                ? Sym->getName()
+                : F.getFnAttribute("wasm-import-name").getValueAsString();
         Sym->setImportName(storeName(Name));
         getTargetStreamer()->emitImportName(Sym, Name);
       }
     }
 
     if (F.hasFnAttribute("wasm-export-name")) {
       auto *Sym = cast<MCSymbolWasm>(getSymbol(&F));
       StringRef Name = F.getFnAttribute("wasm-export-name").getValueAsString();
void WebAssemblyAsmPrinter::emitFunctionBodyStart() {
   computeSignatureVTs(F.getFunctionType(), &F, F, TM, ParamVTs, ResultVTs);
 
   auto Signature = signatureFromMVTs(ResultVTs, ParamVTs);
   auto *WasmSym = cast<MCSymbolWasm>(CurrentFnSym);
   WasmSym->setSignature(Signature.get());
   addSignature(std::move(Signature));
   WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
 
-  // FIXME: clean up how params and results are emitted (use signatures)
   getTargetStreamer()->emitFunctionType(WasmSym);
 
   // Emit the function index.
   if (MDNode *Idx = F.getMetadata("wasm.index")) {
     assert(Idx->getNumOperands() == 1);
 
     getTargetStreamer()->emitIndIdx(AsmPrinter::lowerConstant(
         cast<ConstantAsMetadata>(Idx->getOperand(0))->getValue()));

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 ///    second argument to longjmp. mem[__THREW__.val] is a setjmp ID that is
 ///    stored in saveSetjmp. testSetjmp returns a setjmp label, a unique ID to
 ///    each setjmp callsite. Label 0 means this longjmp buffer does not
 ///    correspond to one of the setjmp callsites in this function, so in this
 ///    case we just chain the longjmp to the caller. (Here we call
 ///    emscripten_longjmp, which is different from emscripten_longjmp_jmpbuf.
 ///    emscripten_longjmp_jmpbuf takes jmp_buf as its first argument, while
 ///    emscripten_longjmp takes an int. Both of them will eventually be lowered
-///    to emscripten_longjmp in s2wasm, but here we need two signatures - we
-///    can't translate an int value to a jmp_buf.)
+///    to emscripten_longjmp later, but here we need two signatures - we can't
+///    translate an int value to a jmp_buf.)
 ///    Label -1 means no longjmp occurred. Otherwise we jump to the right
 ///    post-setjmp BB based on the label.
 ///
 ///===----------------------------------------------------------------------===//
 
 #include "WebAssembly.h"
 #include "WebAssemblyTargetMachine.h"
 #include "llvm/ADT/StringExtras.h"
for (Instruction &I : BB) {
         SSA.RewriteUseAfterInsertions(U);
       }
     }
   }
 }
 
 bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
   LLVM_DEBUG(dbgs() << "********** Lower Emscripten EH & SjLj **********\n");
 
   LLVMContext &C = M.getContext();
   IRBuilder<> IRB(C);
 
   Function *SetjmpF = M.getFunction("setjmp");
   Function *LongjmpF = M.getFunction("longjmp");
   bool SetjmpUsed = SetjmpF && !SetjmpF->use_empty();
   bool LongjmpUsed = LongjmpF && !LongjmpF->use_empty();
   bool DoSjLj = EnableSjLj && (SetjmpUsed || LongjmpUsed);
 

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

 // This disables the removal of registers when lowering into MC, as required
 // by some current tests.
 cl::opt<bool>
     WasmKeepRegisters("wasm-keep-registers", cl::Hidden,
                       cl::desc("WebAssembly: output stack registers in"
                                " instruction output for test purposes only."),
                       cl::init(false));
 
+extern cl::opt<bool> EnableEmException;
+extern cl::opt<bool> EnableEmSjLj;
+
 static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI);
 
 MCSymbol *
 WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
   const GlobalValue *Global = MO.getGlobal();
-  auto *WasmSym = cast<MCSymbolWasm>(Printer.getSymbol(Global));
+  if (!isa<Function>(Global))
+    return cast<MCSymbolWasm>(Printer.getSymbol(Global));
 
-  if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
-    const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
-    const TargetMachine &TM = MF.getTarget();
-    const Function &CurrentFunc = MF.getFunction();
+  const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType());
 
-    SmallVector<MVT, 1> ResultMVTs;
-    SmallVector<MVT, 4> ParamMVTs;
-    const auto *const F = dyn_cast<Function>(Global);
-    computeSignatureVTs(FuncTy, F, CurrentFunc, TM, ParamMVTs, ResultMVTs);
-
-    auto Signature = signatureFromMVTs(ResultMVTs, ParamMVTs);
-    WasmSym->setSignature(Signature.get());
-    Printer.addSignature(std::move(Signature));
-    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
-  }
-
+
+  auto *WasmSym = Printer.getMCSymbolForFunction(
+      F, EnableEmException || EnableEmSjLj, Signature.get());
   return WasmSym;
 }
 
 MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
     const MachineOperand &MO) const {
   const char *Name = MO.getSymbolName();
   auto *WasmSym = cast<MCSymbolWasm>(Printer.GetExternalSymbolSymbol(Name));
   const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/LowerAtomic.h"
 #include "llvm/Transforms/Utils.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "wasm"
 
 // Emscripten's asm.js-style exception handling
-static cl::opt<bool> EnableEmException(
+cl::opt<bool> EnableEmException(
     "enable-emscripten-cxx-exceptions",
     cl::desc("WebAssembly Emscripten-style exception handling"),
     cl::init(false));
 
 // Emscripten's asm.js-style setjmp/longjmp handling
-static cl::opt<bool> EnableEmSjLj(
+cl::opt<bool> EnableEmSjLj(
     "enable-emscripten-sjlj",
     cl::desc("WebAssembly Emscripten-style setjmp/longjmp handling"),
     cl::init(false));
 
 // A command-line option to keep implicit locals
 // for the purpose of testing with lit/llc ONLY.
 // This produces output which is not valid WebAssembly, and is not supported
 // by assemblers/disassemblers and other MC based tools.

llvm/test/CodeGen/WebAssembly/function-bitcasts.ll

define void @test_argument() {
   ret void
 }
 
 ; Invokes should be treated like calls
 
 ; CHECK-LABEL: test_invoke:
 ; CHECK:      i32.const   $push[[L1:[0-9]+]]=, call_func{{$}}
 ; CHECK-NEXT: i32.const   $push[[L0:[0-9]+]]=, has_i32_ret{{$}}
-; CHECK-NEXT: call        "__invoke_void_i32()*", $pop[[L1]], $pop[[L0]]{{$}}
+; CHECK-NEXT: call        invoke_vi, $pop[[L1]], $pop[[L0]]{{$}}
 ; CHECK:      i32.const   $push[[L3:[0-9]+]]=, call_func{{$}}
 ; CHECK-NEXT: i32.const   $push[[L2:[0-9]+]]=, has_i32_arg{{$}}
-; CHECK-NEXT: call        "__invoke_void_i32()*", $pop[[L3]], $pop[[L2]]{{$}}
+; CHECK-NEXT: call        invoke_vi, $pop[[L3]], $pop[[L2]]{{$}}
 ; CHECK:      i32.const   $push[[L4:[0-9]+]]=, .Lhas_i32_arg_bitcast.2{{$}}
-; CHECK-NEXT: call        __invoke_void, $pop[[L4]]{{$}}
+; CHECK-NEXT: call        invoke_v, $pop[[L4]]{{$}}
 declare i32 @personality(...)
 define void @test_invoke() personality i32 (...)* @personality {
 entry:
   invoke void @call_func(i32 ()* @has_i32_ret)
           to label %cont unwind label %lpad
 
 cont:
   invoke void @call_func(i32 ()* bitcast (void (i32)* @has_i32_arg to i32 ()*))

llvm/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll

 ; RUN: llc < %s -enable-emscripten-cxx-exceptions | FileCheck %s --check-prefix=EH
 ; RUN: llc < %s -enable-emscripten-sjlj | FileCheck %s --check-prefix=SJLJ
 ; RUN: llc < %s | FileCheck %s --check-prefix=NONE
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
 
-define hidden void @exception() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define void @exception() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; EH-LABEL:   type exception,@function
 ; NONE-LABEL: type exception,@function
 entry:
-  invoke void @foo()
+  invoke void @foo(i32 3)
           to label %try.cont unwind label %lpad
-; EH:   call __invoke_void
-; NONE: call foo
+; EH:     call invoke_vi
+; EH-NOT: call __invoke_void_i32
+; NONE:   call foo
 
 lpad:                                             ; preds = %entry
   %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   %3 = call i8* @__cxa_begin_catch(i8* %1) #2
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:                                         ; preds = %entry, %lpad
   ret void
 }
 
-define hidden void @setjmp_longjmp() {
+define void @setjmp_longjmp() {
 ; SJLJ-LABEL: type setjmp_longjmp,@function
 ; NONE-LABEL: type setjmp_longjmp,@function
 entry:
   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
   %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
   call void @longjmp(%struct.__jmp_buf_tag* %arraydecay1, i32 1) #1
   unreachable
 ; SJLJ: call saveSetjmp
+; SJLJ: i32.const emscripten_longjmp
+; SJLJ-NOT: i32.const emscripten_longjmp_jmpbuf
+; SJLJ: call invoke_vii
+; SJLJ-NOT: call "__invoke_void_%struct.__jmp_buf_tag*_i32"
 ; SJLJ: call testSetjmp
+
 ; NONE: call setjmp
 ; NONE: call longjmp
 }
 
-declare void @foo()
+declare void @foo(i32)
 declare i32 @__gxx_personality_v0(...)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 ; Function Attrs: returns_twice
 declare i32 @setjmp(%struct.__jmp_buf_tag*) #0
 ; Function Attrs: noreturn
 declare void @longjmp(%struct.__jmp_buf_tag*, i32) #1
 declare i8* @malloc(i32)
 declare void @free(i8*)
 
 attributes #0 = { returns_twice }
 attributes #1 = { noreturn }
 attributes #2 = { nounwind }
+
+; EH: .functype  invoke_vi (i32, i32) -> ()
+; EH: .import_module  invoke_vi, env
+; EH: .import_name  invoke_vi, invoke_vi
+; EH-NOT: .functype  __invoke_void_i32
+; EH-NOT: .import_module  __invoke_void_i32
+; EH-NOT: .import_name  __invoke_void_i32
+
+; SJLJ: .functype  emscripten_longjmp (i32, i32) -> ()
+; SJLJ: .import_module  emscripten_longjmp, env
+; SJLJ: .import_name  emscripten_longjmp, emscripten_longjmp
+; SJLJ-NOT: .functype  emscripten_longjmp_jmpbuf
+; SJLJ-NOT: .import_module  emscripten_longjmp_jmpbuf
+; SJLJ-NOT: .import_name  emscripten_longjmp_jmpbuf

llvm/test/CodeGen/WebAssembly/lower-em-sjlj-sret.ll

 entry:
   %env = alloca [1 x %struct.__jmp_buf_tag], align 16
   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %env, i32 0, i32 0
   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
   ; This is the function pointer to pass to invoke.
   ; It needs to be the first argument (that's what we're testing here)
   ; CHECK: i32.const $push[[FPTR:[0-9]+]]=, returns_struct
   ; This is the sret stack region (as an offset from the stack pointer local)
-  ; CHECK: call "__invoke_{i32.i32}", $pop[[FPTR]]
+  ; CHECK: call invoke_vi, $pop[[FPTR]]
   %ret = call {i32, i32} @returns_struct()
   ret {i32, i32} %ret
 }
 
 attributes #0 = { returns_twice }