[WebAssembly] Update WebAssemblyLowerEmscriptenEHSjLj to support separate compilation.

[sbc100]

Summary

Previously this pass would assume that it was running over the
entire program. This meant it could get away with creating the
two helper functions:

• setThrew
• setTempRet0

Instead we now assume these will be provided at link time. In
emscripten this will most likely be done via libcxxabi.

Additionally we previously created three global variable:

• THREW
• _threwValue
• __tempRet0

These are now allow assumed to be available at link time, but
we also have to handle the case where they exist in the module
being compiled (e.g. when we are doing LTO with libcxxabi).

[sbc100]

• comment

[sbc100]

-revert

[aheejin]

1. For emscripten-based EH, we don't use a separate libcxxabi; emscripten provides handful of library functions in JavaScript. Are you planning to provide them from emscripten and import them from wasm?
2. Because now this does not create those functions and global variables anymore, certain tests, such as lower-em-exceptions.ll, will fail. I guess you should update that as well.

[sbc100]

Emscripten does have at least part of libcxxabi. All I need a library file where I can add these things. Here is my provisional change: https://github.com/kripken/emscripten/compare/sjlj?expand=1

Ah yes, thanks for pointing out that test. I will run them all an fix up.

[aheejin]

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

72

Because you are gonna provide setThrew and setTempRet0 in a separate cpp file, "their values should be set in JS code" does not strictly sound correct, because that cpp file is gonna be a part of wasm as well. Could you elaborate that these functions will be provided from library that's a part of emscripten?

And for the equivalent asm.js version of JS code below ↓ , I know that's not a part of your change, but I think we can delete this by now, because we are gonna switch to the wasm as a default backend anyway. Maybe show the code in cpp form would be better.

339

Nit: LLVM style is GlobalVariable *V

632

threwValue -> __threwValue

[jgravelle-google]

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

487

Nit: unneeded braces

[sbc100]

Abandoning in favor of weak linking approach: https://reviews.llvm.org/D49263

[dschuff]

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

487

Nit: no, those braces are needed IMHO :D

[sbc100]

Re-opening since we need these symbols to be available pre-LTO.. i.e. before codegen.

[sbc100]

Rebase and fix tests

[sbc100]

• feedback

[sbc100]

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

487

At least in lld the policy is not to include them this these cases.

[sbc100]

• feedback

[sbc100]

ptal

[sbc100]

Rebase

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 /// We assume setjmp-longjmp handling always run after EH handling, which means
 /// we don't expect any exception-related instructions when SjLj runs.
 /// FIXME Currently this scheme does not support indirect call of setjmp,
 /// because of the limitation of the scheme itself. fastcomp does not support it
 /// either.
 ///
 /// In detail, this pass does following things:
 ///
-/// 1) Create three global variables: __THREW__, __threwValue, and __tempRet0.
+/// 1) Assumes the existence of global variables: __THREW__, __threwValue, and
+///    __tempRet0.
 ///    __tempRet0 will be set within __cxa_find_matching_catch() function in
 ///    JS library, and __THREW__ and __threwValue will be set in invoke wrappers
 ///    in JS glue code. For what invoke wrappers are, refer to 3). These
 ///    variables are used for both exceptions and setjmp/longjmps.
 ///    __THREW__ indicates whether an exception or a longjmp occurred or not. 0
 ///    means nothing occurred, 1 means an exception occurred, and other numbers
 ///    mean a longjmp occurred. In the case of longjmp, __threwValue variable
 ///    indicates the corresponding setjmp buffer the longjmp corresponds to.
 ///    In exception handling, __tempRet0 indicates the type of an exception
 ///    caught, and in setjmp/longjmp, it means the second argument to longjmp
 ///    function.
 ///
 /// * Exception handling
 ///
-/// 2) Create setThrew and setTempRet0 functions.
-///    The global variables created in 1) will exist in wasm address space,
-///    but their values should be set in JS code, so we provide these functions
+/// 2) We assume the existence of setThrew and setTempRet0 functions at link
+///    time.
+///    The global variables in 1) will exist in wasm address space,
+///    but their values should be set in JS code, so these functions
 ///    as interfaces to JS glue code. These functions are equivalent to the
 ///    following JS functions, which actually exist in asm.js version of JS
 ///    library.
 ///
 ///    function setThrew(threw, value) {
 ///      if (__THREW__ == 0) {
 ///        __THREW__ = threw;
 ///        __threwValue = value;
static cl::list<std::string>
     EHWhitelist("emscripten-cxx-exceptions-whitelist",
                 cl::desc("The list of function names in which Emscripten-style "
                          "exception handling is enabled (see emscripten "
                          "EMSCRIPTEN_CATCHING_WHITELIST options)"),
                 cl::CommaSeparated);
 
 namespace {
 class WebAssemblyLowerEmscriptenEHSjLj final : public ModulePass {
-  static const char *ThrewGVName;
-  static const char *ThrewValueGVName;
-  static const char *TempRet0GVName;
   static const char *ResumeFName;
   static const char *EHTypeIDFName;
-  static const char *SetThrewFName;
-  static const char *SetTempRet0FName;
   static const char *EmLongjmpFName;
   static const char *EmLongjmpJmpbufFName;
   static const char *SaveSetjmpFName;
   static const char *TestSetjmpFName;
   static const char *FindMatchingCatchPrefix;
   static const char *InvokePrefix;
 
   bool EnableEH;   // Enable exception handling
class WebAssemblyLowerEmscriptenEHSjLj final : public ModulePass {
   void wrapTestSetjmp(BasicBlock *BB, Instruction *InsertPt, Value *Threw,
                       Value *SetjmpTable, Value *SetjmpTableSize, Value *&Label,
                       Value *&LongjmpResult, BasicBlock *&EndBB);
   template <typename CallOrInvoke> Function *getInvokeWrapper(CallOrInvoke *CI);
 
   bool areAllExceptionsAllowed() const { return EHWhitelistSet.empty(); }
   bool canLongjmp(Module &M, const Value *Callee) const;
 
-  void createSetThrewFunction(Module &M);
-  void createSetTempRet0Function(Module &M);
-
   void rebuildSSA(Function &F);
 
 public:
   static char ID;
 
   WebAssemblyLowerEmscriptenEHSjLj(bool EnableEH = true, bool EnableSjLj = true)
       : ModulePass(ID), EnableEH(EnableEH), EnableSjLj(EnableSjLj),
         ThrewGV(nullptr), ThrewValueGV(nullptr), TempRet0GV(nullptr),
         ResumeF(nullptr), EHTypeIDF(nullptr), EmLongjmpF(nullptr),
         EmLongjmpJmpbufF(nullptr), SaveSetjmpF(nullptr), TestSetjmpF(nullptr) {
     EHWhitelistSet.insert(EHWhitelist.begin(), EHWhitelist.end());
   }
   bool runOnModule(Module &M) override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<DominatorTreeWrapperPass>();
   }
 };
 } // End anonymous namespace
 
-const char *WebAssemblyLowerEmscriptenEHSjLj::ThrewGVName = "__THREW__";
-const char *WebAssemblyLowerEmscriptenEHSjLj::ThrewValueGVName = "__threwValue";
-const char *WebAssemblyLowerEmscriptenEHSjLj::TempRet0GVName = "__tempRet0";
 const char *WebAssemblyLowerEmscriptenEHSjLj::ResumeFName = "__resumeException";
 const char *WebAssemblyLowerEmscriptenEHSjLj::EHTypeIDFName =
     "llvm_eh_typeid_for";
-const char *WebAssemblyLowerEmscriptenEHSjLj::SetThrewFName = "setThrew";
-const char *WebAssemblyLowerEmscriptenEHSjLj::SetTempRet0FName = "setTempRet0";
 const char *WebAssemblyLowerEmscriptenEHSjLj::EmLongjmpFName =
     "emscripten_longjmp";
 const char *WebAssemblyLowerEmscriptenEHSjLj::EmLongjmpJmpbufFName =
     "emscripten_longjmp_jmpbuf";
 const char *WebAssemblyLowerEmscriptenEHSjLj::SaveSetjmpFName = "saveSetjmp";
 const char *WebAssemblyLowerEmscriptenEHSjLj::TestSetjmpFName = "testSetjmp";
 const char *WebAssemblyLowerEmscriptenEHSjLj::FindMatchingCatchPrefix =
     "__cxa_find_matching_catch_";
if (const auto *F = dyn_cast<const Function>(V)) {
     if (Name == "setjmp" || Name == "longjmp")
       return false;
     return !F->doesNotThrow();
   }
   // not a function, so an indirect call - can throw, we can't tell
   return true;
 }
 
-// Returns an available name for a global value.
-// If the proposed name already exists in the module, adds '_' at the end of
-// the name until the name is available.
-static inline std::string createGlobalValueName(const Module &M,
-                                                const std::string &Propose) {
-  std::string Name = Propose;
-  while (M.getNamedGlobal(Name))
-    Name += "_";
-  return Name;
+// Get a global variable with the given name.  If it doesn't exist declare it,
+// which will generate an import and asssumes that it will exist at link time.
+static GlobalVariable *getGlobalVariable(Module &M, Type *Ty,
+                                         const std::string &Name) {
+  GlobalVariable* V = M.getNamedGlobal(Name);
+  if (V)
+    return V;
+  return new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage, nullptr,
+                            Name);
 }
 
 // Simple function name mangler.
 // This function simply takes LLVM's string representation of parameter types
 // and concatenate them with '_'. There are non-alphanumeric characters but llc
 // is ok with it, and we need to postprocess these names after the lowering
 // phase anyway.
 static std::string getSignature(FunctionType *FTy) {
Function *WebAssemblyLowerEmscriptenEHSjLj::getInvokeWrapper(CallOrInvoke *CI) {
   Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage,
                                  InvokePrefix + Sig, M);
   InvokeWrappers[Sig] = F;
   return F;
 }
 
 bool WebAssemblyLowerEmscriptenEHSjLj::canLongjmp(Module &M,
                                                   const Value *Callee) const {
-  if (auto *CalleeF = dyn_cast<Function>(Callee))
+  if (auto *CalleeF = dyn_cast<Function>(Callee)) {
     if (CalleeF->isIntrinsic())
       return false;
+  }
 
   // The reason we include malloc/free here is to exclude the malloc/free
   // calls generated in setjmp prep / cleanup routines.
   Function *SetjmpF = M.getFunction("setjmp");
   Function *MallocF = M.getFunction("malloc");
   Function *FreeF = M.getFunction("free");
   if (Callee == SetjmpF || Callee == MallocF || Callee == FreeF)
     return false;
void WebAssemblyLowerEmscriptenEHSjLj::wrapTestSetjmp(
   LabelPHI->addIncoming(IRB.getInt32(-1), ElseBB1);
 
   // Output parameter assignment
   Label = LabelPHI;
   EndBB = EndBB1;
   LongjmpResult = IRB.CreateLoad(TempRet0GV, "longjmp_result");
 }
 
-// Create setThrew function
-// function setThrew(threw, value) {
-//   if (__THREW__ == 0) {
-//     __THREW__ = threw;
-//     __threwValue = value;
-//   }
-// }
-void WebAssemblyLowerEmscriptenEHSjLj::createSetThrewFunction(Module &M) {
-  LLVMContext &C = M.getContext();
-  IRBuilder<> IRB(C);
-
-  assert(!M.getNamedGlobal(SetThrewFName) && "setThrew already exists");
-  Type *Params[] = {IRB.getInt32Ty(), IRB.getInt32Ty()};
-  FunctionType *FTy = FunctionType::get(IRB.getVoidTy(), Params, false);
-  Function *F =
-      Function::Create(FTy, GlobalValue::ExternalLinkage, SetThrewFName, &M);
-  Argument *Arg1 = &*(F->arg_begin());
-  Argument *Arg2 = &*std::next(F->arg_begin());
-  Arg1->setName("threw");
-  Arg2->setName("value");
-  BasicBlock *EntryBB = BasicBlock::Create(C, "entry", F);
-  BasicBlock *ThenBB = BasicBlock::Create(C, "if.then", F);
-  BasicBlock *EndBB = BasicBlock::Create(C, "if.end", F);
-
-  IRB.SetInsertPoint(EntryBB);
-  Value *Threw = IRB.CreateLoad(ThrewGV, ThrewGV->getName() + ".val");
-  Value *Cmp = IRB.CreateICmpEQ(Threw, IRB.getInt32(0), "cmp");
-  IRB.CreateCondBr(Cmp, ThenBB, EndBB);
-
-  IRB.SetInsertPoint(ThenBB);
-  IRB.CreateStore(Arg1, ThrewGV);
-  IRB.CreateStore(Arg2, ThrewValueGV);
-  IRB.CreateBr(EndBB);
-
-  IRB.SetInsertPoint(EndBB);
-  IRB.CreateRetVoid();
-}
-
-// Create setTempRet0 function
-// function setTempRet0(value) {
-//   __tempRet0 = value;
-// }
-void WebAssemblyLowerEmscriptenEHSjLj::createSetTempRet0Function(Module &M) {
-  LLVMContext &C = M.getContext();
-  IRBuilder<> IRB(C);
-
-  assert(!M.getNamedGlobal(SetTempRet0FName) && "setTempRet0 already exists");
-  Type *Params[] = {IRB.getInt32Ty()};
-  FunctionType *FTy = FunctionType::get(IRB.getVoidTy(), Params, false);
-  Function *F =
-      Function::Create(FTy, GlobalValue::ExternalLinkage, SetTempRet0FName, &M);
-  F->arg_begin()->setName("value");
-  BasicBlock *EntryBB = BasicBlock::Create(C, "entry", F);
-  IRB.SetInsertPoint(EntryBB);
-  IRB.CreateStore(&*F->arg_begin(), TempRet0GV);
-  IRB.CreateRetVoid();
-}
-
 void WebAssemblyLowerEmscriptenEHSjLj::rebuildSSA(Function &F) {
   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
   DT.recalculate(F); // CFG has been changed
   SSAUpdater SSA;
   for (BasicBlock &BB : F) {
     for (Instruction &I : BB) {
       for (auto UI = I.use_begin(), UE = I.use_end(); UI != UE;) {
         Use &U = *UI;
bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
   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);
 
-  // Create global variables __THREW__, threwValue, and __tempRet0, which are
-  // used in common for both exception handling and setjmp/longjmp handling
-  ThrewGV = new GlobalVariable(M, IRB.getInt32Ty(), false,
-                               GlobalValue::ExternalLinkage, IRB.getInt32(0),
-                               createGlobalValueName(M, ThrewGVName));
-  ThrewValueGV = new GlobalVariable(
-      M, IRB.getInt32Ty(), false, GlobalValue::ExternalLinkage, IRB.getInt32(0),
-      createGlobalValueName(M, ThrewValueGVName));
-  TempRet0GV = new GlobalVariable(M, IRB.getInt32Ty(), false,
-                                  GlobalValue::ExternalLinkage, IRB.getInt32(0),
-                                  createGlobalValueName(M, TempRet0GVName));
+  // Declare (or get) global variables __THREW__, threwValue, and __tempRet0,
+  // which are used in common for both exception handling and setjmp/longjmp
+  // handling
+  ThrewGV = getGlobalVariable(M, IRB.getInt32Ty(), "__THREW__");
+  ThrewValueGV = getGlobalVariable(M, IRB.getInt32Ty(), "__threwValue");
+  TempRet0GV = getGlobalVariable(M, IRB.getInt32Ty(), "__tempRet0");
 
   bool Changed = false;
 
   // Exception handling
   if (EnableEH) {
     // Register __resumeException function
     FunctionType *ResumeFTy =
         FunctionType::get(IRB.getVoidTy(), IRB.getInt8PtrTy(), false);
for (Function &F : M) {
       Changed |= runEHOnFunction(F);
     }
   }
 
   // Setjmp/longjmp handling
   if (DoSjLj) {
     Changed = true; // We have setjmp or longjmp somewhere
 
-    Function *MallocF = M.getFunction("malloc");
-    Function *FreeF = M.getFunction("free");
-    if (!MallocF || !FreeF)
-      report_fatal_error(
-          "malloc and free must be linked into the module if setjmp is used");
-
     // Register saveSetjmp function
     FunctionType *SetjmpFTy = SetjmpF->getFunctionType();
     SmallVector<Type *, 4> Params = {SetjmpFTy->getParamType(0),
                                      IRB.getInt32Ty(), Type::getInt32PtrTy(C),
                                      IRB.getInt32Ty()};
     FunctionType *FTy =
         FunctionType::get(Type::getInt32PtrTy(C), Params, false);
     SaveSetjmpF = Function::Create(FTy, GlobalValue::ExternalLinkage,
for (User *U : SetjmpF->users()) {
       SetjmpUsers.insert(UI->getFunction());
     }
     for (Function *F : SetjmpUsers)
       runSjLjOnFunction(*F);
   }
 
   if (!Changed) {
     // Delete unused global variables and functions
-    ThrewGV->eraseFromParent();
-    ThrewValueGV->eraseFromParent();
-    TempRet0GV->eraseFromParent();
     if (ResumeF)
       ResumeF->eraseFromParent();
     if (EHTypeIDF)
       EHTypeIDF->eraseFromParent();
     if (EmLongjmpF)
       EmLongjmpF->eraseFromParent();
     if (SaveSetjmpF)
       SaveSetjmpF->eraseFromParent();
     if (TestSetjmpF)
       TestSetjmpF->eraseFromParent();
     return false;
   }
 
-  // If we have made any changes while doing exception handling or
-  // setjmp/longjmp handling, we have to create these functions for JavaScript
-  // to call.
-  createSetThrewFunction(M);
-  createSetTempRet0Function(M);
-
   return true;
 }
 
 bool WebAssemblyLowerEmscriptenEHSjLj::runEHOnFunction(Function &F) {
   Module &M = *F.getParent();
   LLVMContext &C = F.getContext();
   IRBuilder<> IRB(C);
   bool Changed = false;