llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenExceptions.cpp - toolchain/llvm-project - Gitiles

 // WebAssemblyLowerEmscriptenExceptions.cpp - Lower exceptions for Emscripten //
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief This file lowers exception-related instructions in order to use
 /// Emscripten's JavaScript try and catch mechanism to handle exceptions.
 ///
 /// To handle exceptions, this scheme relies on JavaScript's try and catch
 /// syntax and relevant exception-related libraries implemented in JavaScript
 /// glue code that will be produced by Emscripten. This is similar to the
 /// current Emscripten asm.js exception handling in fastcomp.
 /// For fastcomp's EH scheme, see these files in fastcomp LLVM branch:
 /// (Location: https://github.com/kripken/emscripten-fastcomp)
 /// lib/Target/JSBackend/NaCl/LowerEmExceptionsPass.cpp
 /// lib/Target/JSBackend/JSBackend.cpp
 /// lib/Target/JSBackend/CallHandlers.h
 ///
 /// This pass does following things:
 ///
 /// 1) Create three 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).
 ///
 /// 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
 ///    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;
 ///      }
 ///    }
 ///
 ///    function setTempRet0(value) {
 ///      tempRet0 = value;
 ///    }
 ///
 /// 3) Lower
 ///      invoke @func(arg1, arg2) to label %invoke.cont unwind label %lpad
 ///    into
 ///      __THREW__ = 0;
 ///      call @invoke_SIG(func, arg1, arg2)
 ///      %__THREW__.val = __THREW__;
 ///      __THREW__ = 0;
 ///      br %__THREW__.val, label %lpad, label %invoke.cont
 ///    SIG is a mangled string generated based on the LLVM IR-level function
 ///    signature. After LLVM IR types are lowered to the target wasm types,
 ///    the names for these wrappers will change based on wasm types as well,
 ///    as in invoke_vi (function takes an int and returns void). The bodies of
 ///    these wrappers will be generated in JS glue code, and inside those
 ///    wrappers we use JS try-catch to generate actual exception effects. It
 ///    also calls the original callee function. An example wrapper in JS code
 ///    would look like this:
 ///      function invoke_vi(index,a1) {
 ///        try {
 ///          Module["dynCall_vi"](index,a1); // This calls original callee
 ///        } catch(e) {
 ///          if (typeof e !== 'number' && e !== 'longjmp') throw e;
 ///          asm["setThrew"](1, 0); // setThrew is called here
 ///        }
 ///      }
 ///    If an exception is thrown, __THREW__ will be set to true in a wrapper,
 ///    so we can jump to the right BB based on this value.
 ///
 /// 4) Lower
 ///      %val = landingpad catch c1 catch c2 catch c3 ...
 ///      ... use %val ...
 ///    into
 ///      %fmc = call @__cxa_find_matching_catch_N(c1, c2, c3, ...)
 ///      %val = {%fmc, tempRet0}
 ///      ... use %val ...
 ///    Here N is a number calculated based on the number of clauses.
 ///    Global variable tempRet0 is set within __cxa_find_matching_catch() in
 ///    JS glue code.
 ///
 /// 5) Lower
 ///      resume {%a, %b}
 ///    into
 ///      call @__resumeException(%a)
 ///    where __resumeException() is a function in JS glue code.
 ///
 /// 6) Lower
 ///      call @llvm.eh.typeid.for(type) (intrinsic)
 ///    into
 ///      call @llvm_eh_typeid_for(type)
 ///    llvm_eh_typeid_for function will be generated in JS glue code.
 ///
 ///===----------------------------------------------------------------------===//

 #include "WebAssembly.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/raw_ostream.h"
 #include <set>

 using namespace llvm;

 #define DEBUG_TYPE "wasm-lower-em-exceptions"

 static cl::list<std::string>
     Whitelist("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 WebAssemblyLowerEmscriptenExceptions final : public ModulePass {
   const char *getPassName() const override {
     return "WebAssembly Lower Emscripten Exceptions";
   }

   bool runOnFunction(Function &F);
   // Returns __cxa_find_matching_catch_N function, where N = NumClauses + 2.
   // This is because a landingpad instruction contains two more arguments,
   // a personality function and a cleanup bit, and __cxa_find_matching_catch_N
   // functions are named after the number of arguments in the original
   // landingpad instruction.
   Function *getFindMatchingCatch(Module &M, unsigned NumClauses);

   Function *getInvokeWrapper(Module &M, InvokeInst *II);
   bool areAllExceptionsAllowed() const { return WhitelistSet.empty(); }

   GlobalVariable *ThrewGV;      // __THREW__
   GlobalVariable *ThrewValueGV; // threwValue
   GlobalVariable *TempRet0GV;   // tempRet0
   Function *ResumeF;            // __resumeException
   Function *EHTypeIdF;          // llvm_eh_typeid_for
   // __cxa_find_matching_catch_N functions.
   // Indexed by the number of clauses in an original landingpad instruction.
   DenseMap<int, Function *> FindMatchingCatches;
   // Map of <function signature string, invoke_ wrappers>
   StringMap<Function *> InvokeWrappers;
   // Set of whitelisted function names
   std::set<std::string> WhitelistSet;

 public:
   static char ID;

   WebAssemblyLowerEmscriptenExceptions()
       : ModulePass(ID), ThrewGV(nullptr), ThrewValueGV(nullptr),
         TempRet0GV(nullptr) {
     WhitelistSet.insert(Whitelist.begin(), Whitelist.end());
   }
   bool runOnModule(Module &M) override;
 };
 } // End anonymous namespace

 char WebAssemblyLowerEmscriptenExceptions::ID = 0;
 INITIALIZE_PASS(WebAssemblyLowerEmscriptenExceptions, DEBUG_TYPE,
                 "WebAssembly Lower Emscripten Exceptions", false, false)

 ModulePass *llvm::createWebAssemblyLowerEmscriptenExceptions() {
   return new WebAssemblyLowerEmscriptenExceptions();
 }

 static bool canThrow(const Value *V) {
   if (const auto *F = dyn_cast<const Function>(V)) {
     // Intrinsics cannot throw
     if (F->isIntrinsic())
       return false;
     StringRef Name = F->getName();
     // leave setjmp and longjmp (mostly) alone, we process them properly later
     if (Name == "setjmp" || Name == "longjmp")
       return false;
     return true;
   }
   return true; // not a function, so an indirect call - can throw, we can't tell
 }

 // 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;
 }

 // 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) {
   std::string Sig;
   raw_string_ostream OS(Sig);
   OS << *FTy->getReturnType();
   for (Type *ParamTy : FTy->params())
     OS << "_" << *ParamTy;
   if (FTy->isVarArg())
     OS << "_...";
   Sig = OS.str();
   Sig.erase(std::remove_if(Sig.begin(), Sig.end(), isspace), Sig.end());
   // When s2wasm parses .s file, a comma means the end of an argument. So a
   // mangled function name can contain any character but a comma.
   std::replace(Sig.begin(), Sig.end(), ',', '.');
   return Sig;
 }

 Function *WebAssemblyLowerEmscriptenExceptions::getFindMatchingCatch(
     Module &M, unsigned NumClauses) {
   if (FindMatchingCatches.count(NumClauses))
     return FindMatchingCatches[NumClauses];
   PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
   SmallVector<Type *, 16> Args(NumClauses, Int8PtrTy);
   FunctionType *FTy = FunctionType::get(Int8PtrTy, Args, false);
   Function *F = Function::Create(
       FTy, GlobalValue::ExternalLinkage,
       "__cxa_find_matching_catch_" + Twine(NumClauses + 2), &M);
   FindMatchingCatches[NumClauses] = F;
   return F;
 }

 Function *
 WebAssemblyLowerEmscriptenExceptions::getInvokeWrapper(Module &M,
                                                        InvokeInst *II) {
   SmallVector<Type *, 16> ArgTys;
   Value *Callee = II->getCalledValue();
   FunctionType *CalleeFTy;
   if (auto *F = dyn_cast<Function>(Callee))
     CalleeFTy = F->getFunctionType();
   else {
     auto *CalleeTy = dyn_cast<PointerType>(Callee->getType())->getElementType();
     CalleeFTy = dyn_cast<FunctionType>(CalleeTy);
   }

   std::string Sig = getSignature(CalleeFTy);
   if (InvokeWrappers.find(Sig) != InvokeWrappers.end())
     return InvokeWrappers[Sig];

   // Put the pointer to the callee as first argument
   ArgTys.push_back(PointerType::getUnqual(CalleeFTy));
   // Add argument types
   ArgTys.append(CalleeFTy->param_begin(), CalleeFTy->param_end());

   FunctionType *FTy = FunctionType::get(CalleeFTy->getReturnType(), ArgTys,
                                         CalleeFTy->isVarArg());
   Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage,
                                  "__invoke_" + Sig, &M);
   InvokeWrappers[Sig] = F;
   return F;
 }

 bool WebAssemblyLowerEmscriptenExceptions::runOnModule(Module &M) {
   LLVMContext &C = M.getContext();
   IRBuilder<> Builder(C);
   IntegerType *Int1Ty = Builder.getInt1Ty();
   PointerType *Int8PtrTy = Builder.getInt8PtrTy();
   IntegerType *Int32Ty = Builder.getInt32Ty();
   Type *VoidTy = Builder.getVoidTy();

   // Create global variables __THREW__, threwValue, and tempRet0
   ThrewGV = new GlobalVariable(M, Int1Ty, false, GlobalValue::ExternalLinkage,
                                Builder.getFalse(),
                                createGlobalValueName(M, "__THREW__"));
   ThrewValueGV = new GlobalVariable(
       M, Int32Ty, false, GlobalValue::ExternalLinkage, Builder.getInt32(0),
       createGlobalValueName(M, "threwValue"));
   TempRet0GV = new GlobalVariable(
       M, Int32Ty, false, GlobalValue::ExternalLinkage, Builder.getInt32(0),
       createGlobalValueName(M, "tempRet0"));

   // Register __resumeException function
   FunctionType *ResumeFTy = FunctionType::get(VoidTy, Int8PtrTy, false);
   ResumeF = Function::Create(ResumeFTy, GlobalValue::ExternalLinkage,
                              "__resumeException", &M);

   // Register llvm_eh_typeid_for function
   FunctionType *EHTypeIdTy = FunctionType::get(Int32Ty, Int8PtrTy, false);
   EHTypeIdF = Function::Create(EHTypeIdTy, GlobalValue::ExternalLinkage,
                                "llvm_eh_typeid_for", &M);

   bool Changed = false;
   for (Function &F : M) {
     if (F.isDeclaration())
       continue;
     Changed |= runOnFunction(F);
   }

   if (!Changed)
     return false;

   assert(!M.getNamedGlobal("setThrew") && "setThrew already exists");
   assert(!M.getNamedGlobal("setTempRet0") && "setTempRet0 already exists");

   // Create setThrew function
   SmallVector<Type *, 2> Params = {Int1Ty, Int32Ty};
   FunctionType *FTy = FunctionType::get(VoidTy, Params, false);
   Function *F =
       Function::Create(FTy, GlobalValue::ExternalLinkage, "setThrew", &M);
   Argument *Arg1 = &*(F->arg_begin());
   Argument *Arg2 = &*(++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);

   Builder.SetInsertPoint(EntryBB);
   Value *Threw = Builder.CreateLoad(ThrewGV, ThrewGV->getName() + ".val");
   Value *Cmp = Builder.CreateICmpEQ(Threw, Builder.getFalse(), "cmp");
   Builder.CreateCondBr(Cmp, ThenBB, EndBB);

   Builder.SetInsertPoint(ThenBB);
   Builder.CreateStore(Arg1, ThrewGV);
   Builder.CreateStore(Arg2, ThrewValueGV);
   Builder.CreateBr(EndBB);

   Builder.SetInsertPoint(EndBB);
   Builder.CreateRetVoid();

   // Create setTempRet0 function
   Params = {Int32Ty};
   FTy = FunctionType::get(VoidTy, Params, false);
   F = Function::Create(FTy, GlobalValue::ExternalLinkage, "setTempRet0", &M);
   F->arg_begin()->setName("value");
   EntryBB = BasicBlock::Create(C, "entry", F);
   Builder.SetInsertPoint(EntryBB);
   Builder.CreateStore(&*F->arg_begin(), TempRet0GV);
   Builder.CreateRetVoid();

   return true;
 }

 bool WebAssemblyLowerEmscriptenExceptions::runOnFunction(Function &F) {
   Module &M = *F.getParent();
   LLVMContext &C = F.getContext();
   IRBuilder<> Builder(C);
   bool Changed = false;
   SmallVector<Instruction *, 64> ToErase;
   SmallPtrSet<LandingPadInst *, 32> LandingPads;
   bool AllowExceptions =
       areAllExceptionsAllowed() || WhitelistSet.count(F.getName());

   for (BasicBlock &BB : F) {
     auto *II = dyn_cast<InvokeInst>(BB.getTerminator());
     if (!II)
       continue;
     Changed = true;
     LandingPads.insert(II->getLandingPadInst());
     Builder.SetInsertPoint(II);

     bool NeedInvoke = AllowExceptions && canThrow(II->getCalledValue());
     if (NeedInvoke) {
       // If we are calling a function that is noreturn, we must remove that
       // attribute. The code we insert here does expect it to return, after we
       // catch the exception.
       if (II->doesNotReturn()) {
         if (auto *F = dyn_cast<Function>(II->getCalledValue()))
           F->removeFnAttr(Attribute::NoReturn);
         AttributeSet NewAttrs = II->getAttributes();
         NewAttrs.removeAttribute(C, AttributeSet::FunctionIndex,
                                  Attribute::NoReturn);
         II->setAttributes(NewAttrs);
       }

       // Pre-invoke
       // __THREW__ = 0;
       Builder.CreateStore(Builder.getFalse(), ThrewGV);

       // Invoke function wrapper in JavaScript
       SmallVector<Value *, 16> CallArgs;
       // Put the pointer to the callee as first argument, so it can be called
       // within the invoke wrapper later
       CallArgs.push_back(II->getCalledValue());
       CallArgs.append(II->arg_begin(), II->arg_end());
       CallInst *NewCall = Builder.CreateCall(getInvokeWrapper(M, II), CallArgs);
       NewCall->takeName(II);
       NewCall->setCallingConv(II->getCallingConv());
       NewCall->setDebugLoc(II->getDebugLoc());

       // Because we added the pointer to the callee as first argument, all
       // argument attribute indices have to be incremented by one.
       SmallVector<AttributeSet, 8> AttributesVec;
       const AttributeSet &InvokePAL = II->getAttributes();
       CallSite::arg_iterator AI = II->arg_begin();
       unsigned i = 1; // Argument attribute index starts from 1
       for (unsigned e = II->getNumArgOperands(); i <= e; ++AI, ++i) {
         if (InvokePAL.hasAttributes(i)) {
           AttrBuilder B(InvokePAL, i);
           AttributesVec.push_back(AttributeSet::get(C, i + 1, B));
         }
       }
       // Add any return attributes.
       if (InvokePAL.hasAttributes(AttributeSet::ReturnIndex))
         AttributesVec.push_back(
             AttributeSet::get(C, InvokePAL.getRetAttributes()));
       // Add any function attributes.
       if (InvokePAL.hasAttributes(AttributeSet::FunctionIndex))
         AttributesVec.push_back(
             AttributeSet::get(C, InvokePAL.getFnAttributes()));
       // Reconstruct the AttributesList based on the vector we constructed.
       AttributeSet NewCallPAL = AttributeSet::get(C, AttributesVec);
       NewCall->setAttributes(NewCallPAL);

       II->replaceAllUsesWith(NewCall);
       ToErase.push_back(II);

       // Post-invoke
       // %__THREW__.val = __THREW__; __THREW__ = 0;
       Value *Threw = Builder.CreateLoad(ThrewGV, ThrewGV->getName() + ".val");
       Builder.CreateStore(Builder.getFalse(), ThrewGV);

       // Insert a branch based on __THREW__ variable
       Builder.CreateCondBr(Threw, II->getUnwindDest(), II->getNormalDest());

     } else {
       // This can't throw, and we don't need this invoke, just replace it with a
       // call+branch
       SmallVector<Value *, 16> CallArgs(II->arg_begin(), II->arg_end());
       CallInst *NewCall = Builder.CreateCall(II->getCalledValue(), CallArgs);
       NewCall->takeName(II);
       NewCall->setCallingConv(II->getCallingConv());
       NewCall->setDebugLoc(II->getDebugLoc());
       NewCall->setAttributes(II->getAttributes());
       II->replaceAllUsesWith(NewCall);
       ToErase.push_back(II);

       Builder.CreateBr(II->getNormalDest());

       // Remove any PHI node entries from the exception destination
       II->getUnwindDest()->removePredecessor(&BB);
     }
   }

   // Process resume instructions
   for (BasicBlock &BB : F) {
     // Scan the body of the basic block for resumes
     for (Instruction &I : BB) {
       auto *RI = dyn_cast<ResumeInst>(&I);
       if (!RI)
         continue;

       // Split the input into legal values
       Value *Input = RI->getValue();
       Builder.SetInsertPoint(RI);
       Value *Low = Builder.CreateExtractValue(Input, 0, "low");

       // Create a call to __resumeException function
       Value *Args[] = {Low};
       Builder.CreateCall(ResumeF, Args);

       // Add a terminator to the block
       Builder.CreateUnreachable();
       ToErase.push_back(RI);
     }
   }

   // Process llvm.eh.typeid.for intrinsics
   for (BasicBlock &BB : F) {
     for (Instruction &I : BB) {
       auto *CI = dyn_cast<CallInst>(&I);
       if (!CI)
         continue;
       const Function *Callee = CI->getCalledFunction();
       if (!Callee)
         continue;
       if (Callee->getIntrinsicID() != Intrinsic::eh_typeid_for)
         continue;

       Builder.SetInsertPoint(CI);
       CallInst *NewCI =
           Builder.CreateCall(EHTypeIdF, CI->getArgOperand(0), "typeid");
       CI->replaceAllUsesWith(NewCI);
       ToErase.push_back(CI);
     }
   }

   // Look for orphan landingpads, can occur in blocks with no predecesors
   for (BasicBlock &BB : F) {
     Instruction *I = BB.getFirstNonPHI();
     if (auto *LPI = dyn_cast<LandingPadInst>(I))
       LandingPads.insert(LPI);
   }

   // Handle all the landingpad for this function together, as multiple invokes
   // may share a single lp
   for (LandingPadInst *LPI : LandingPads) {
     Builder.SetInsertPoint(LPI);
     SmallVector<Value *, 16> FMCArgs;
     for (unsigned i = 0, e = LPI->getNumClauses(); i < e; ++i) {
       Constant *Clause = LPI->getClause(i);
       // As a temporary workaround for the lack of aggregate varargs support
       // in the interface between JS and wasm, break out filter operands into
       // their component elements.
       if (LPI->isFilter(i)) {
         ArrayType *ATy = cast<ArrayType>(Clause->getType());
         for (unsigned j = 0, e = ATy->getNumElements(); j < e; ++j) {
           Value *EV =
               Builder.CreateExtractValue(Clause, makeArrayRef(j), "filter");
           FMCArgs.push_back(EV);
         }
       } else
         FMCArgs.push_back(Clause);
     }

     // Create a call to __cxa_find_matching_catch_N function
     Function *FMCF = getFindMatchingCatch(M, FMCArgs.size());
     CallInst *FMCI = Builder.CreateCall(FMCF, FMCArgs, "fmc");
     Value *Undef = UndefValue::get(LPI->getType());
     Value *Pair0 = Builder.CreateInsertValue(Undef, FMCI, 0, "pair0");
     Value *TempRet0 =
         Builder.CreateLoad(TempRet0GV, TempRet0GV->getName() + "val");
     Value *Pair1 = Builder.CreateInsertValue(Pair0, TempRet0, 1, "pair1");

     LPI->replaceAllUsesWith(Pair1);
     ToErase.push_back(LPI);
   }

   // Erase everything we no longer need in this function
   for (Instruction *I : ToErase)
     I->eraseFromParent();

   return Changed;
 }
	// WebAssemblyLowerEmscriptenExceptions.cpp - Lower exceptions for Emscripten //
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file
	/// \brief This file lowers exception-related instructions in order to use
	/// Emscripten's JavaScript try and catch mechanism to handle exceptions.
	///
	/// To handle exceptions, this scheme relies on JavaScript's try and catch
	/// syntax and relevant exception-related libraries implemented in JavaScript
	/// glue code that will be produced by Emscripten. This is similar to the
	/// current Emscripten asm.js exception handling in fastcomp.
	/// For fastcomp's EH scheme, see these files in fastcomp LLVM branch:
	/// (Location: https://github.com/kripken/emscripten-fastcomp)
	/// lib/Target/JSBackend/NaCl/LowerEmExceptionsPass.cpp
	/// lib/Target/JSBackend/JSBackend.cpp
	/// lib/Target/JSBackend/CallHandlers.h
	///
	/// This pass does following things:
	///
	/// 1) Create three 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).
	///
	/// 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
	/// 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;
	/// }
	/// }
	///
	/// function setTempRet0(value) {
	/// tempRet0 = value;
	/// }
	///
	/// 3) Lower
	/// invoke @func(arg1, arg2) to label %invoke.cont unwind label %lpad
	/// into
	/// __THREW__ = 0;
	/// call @invoke_SIG(func, arg1, arg2)
	/// %__THREW__.val = __THREW__;
	/// __THREW__ = 0;
	/// br %__THREW__.val, label %lpad, label %invoke.cont
	/// SIG is a mangled string generated based on the LLVM IR-level function
	/// signature. After LLVM IR types are lowered to the target wasm types,
	/// the names for these wrappers will change based on wasm types as well,
	/// as in invoke_vi (function takes an int and returns void). The bodies of
	/// these wrappers will be generated in JS glue code, and inside those
	/// wrappers we use JS try-catch to generate actual exception effects. It
	/// also calls the original callee function. An example wrapper in JS code
	/// would look like this:
	/// function invoke_vi(index,a1) {
	/// try {
	/// Module["dynCall_vi"](index,a1); // This calls original callee
	/// } catch(e) {
	/// if (typeof e !== 'number' && e !== 'longjmp') throw e;
	/// asm["setThrew"](1, 0); // setThrew is called here
	/// }
	/// }
	/// If an exception is thrown, __THREW__ will be set to true in a wrapper,
	/// so we can jump to the right BB based on this value.
	///
	/// 4) Lower
	/// %val = landingpad catch c1 catch c2 catch c3 ...
	/// ... use %val ...
	/// into
	/// %fmc = call @__cxa_find_matching_catch_N(c1, c2, c3, ...)
	/// %val = {%fmc, tempRet0}
	/// ... use %val ...
	/// Here N is a number calculated based on the number of clauses.
	/// Global variable tempRet0 is set within __cxa_find_matching_catch() in
	/// JS glue code.
	///
	/// 5) Lower
	/// resume {%a, %b}
	/// into
	/// call @__resumeException(%a)
	/// where __resumeException() is a function in JS glue code.
	///
	/// 6) Lower
	/// call @llvm.eh.typeid.for(type) (intrinsic)
	/// into
	/// call @llvm_eh_typeid_for(type)
	/// llvm_eh_typeid_for function will be generated in JS glue code.
	///
	///===----------------------------------------------------------------------===//

	#include "WebAssembly.h"
	#include "llvm/IR/CallSite.h"
	#include "llvm/IR/IRBuilder.h"
	#include "llvm/IR/Module.h"
	#include "llvm/Support/raw_ostream.h"
	#include <set>

	using namespace llvm;

	#define DEBUG_TYPE "wasm-lower-em-exceptions"

	static cl::list<std::string>
	Whitelist("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 WebAssemblyLowerEmscriptenExceptions final : public ModulePass {
	const char *getPassName() const override {
	return "WebAssembly Lower Emscripten Exceptions";
	}

	bool runOnFunction(Function &F);
	// Returns __cxa_find_matching_catch_N function, where N = NumClauses + 2.
	// This is because a landingpad instruction contains two more arguments,
	// a personality function and a cleanup bit, and __cxa_find_matching_catch_N
	// functions are named after the number of arguments in the original
	// landingpad instruction.
	Function *getFindMatchingCatch(Module &M, unsigned NumClauses);

	Function getInvokeWrapper(Module &M, InvokeInst II);
	bool areAllExceptionsAllowed() const { return WhitelistSet.empty(); }

	GlobalVariable *ThrewGV; // __THREW__
	GlobalVariable *ThrewValueGV; // threwValue
	GlobalVariable *TempRet0GV; // tempRet0
	Function *ResumeF; // __resumeException
	Function *EHTypeIdF; // llvm_eh_typeid_for
	// __cxa_find_matching_catch_N functions.
	// Indexed by the number of clauses in an original landingpad instruction.
	DenseMap<int, Function *> FindMatchingCatches;
	// Map of <function signature string, invoke_ wrappers>
	StringMap<Function *> InvokeWrappers;
	// Set of whitelisted function names
	std::set<std::string> WhitelistSet;

	public:
	static char ID;

	WebAssemblyLowerEmscriptenExceptions()
	: ModulePass(ID), ThrewGV(nullptr), ThrewValueGV(nullptr),
	TempRet0GV(nullptr) {
	WhitelistSet.insert(Whitelist.begin(), Whitelist.end());
	}
	bool runOnModule(Module &M) override;
	};
	} // End anonymous namespace

	char WebAssemblyLowerEmscriptenExceptions::ID = 0;
	INITIALIZE_PASS(WebAssemblyLowerEmscriptenExceptions, DEBUG_TYPE,
	"WebAssembly Lower Emscripten Exceptions", false, false)

	ModulePass *llvm::createWebAssemblyLowerEmscriptenExceptions() {
	return new WebAssemblyLowerEmscriptenExceptions();
	}

	static bool canThrow(const Value *V) {
	if (const auto *F = dyn_cast<const Function>(V)) {
	// Intrinsics cannot throw
	if (F->isIntrinsic())
	return false;
	StringRef Name = F->getName();
	// leave setjmp and longjmp (mostly) alone, we process them properly later
	if (Name == "setjmp" \|\| Name == "longjmp")
	return false;
	return true;
	}
	return true; // not a function, so an indirect call - can throw, we can't tell
	}

	// 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;
	}

	// 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) {
	std::string Sig;
	raw_string_ostream OS(Sig);
	OS << *FTy->getReturnType();
	for (Type *ParamTy : FTy->params())
	OS << "_" << *ParamTy;
	if (FTy->isVarArg())
	OS << "_...";
	Sig = OS.str();
	Sig.erase(std::remove_if(Sig.begin(), Sig.end(), isspace), Sig.end());
	// When s2wasm parses .s file, a comma means the end of an argument. So a
	// mangled function name can contain any character but a comma.
	std::replace(Sig.begin(), Sig.end(), ',', '.');
	return Sig;
	}

	Function *WebAssemblyLowerEmscriptenExceptions::getFindMatchingCatch(
	Module &M, unsigned NumClauses) {
	if (FindMatchingCatches.count(NumClauses))
	return FindMatchingCatches[NumClauses];
	PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
	SmallVector<Type *, 16> Args(NumClauses, Int8PtrTy);
	FunctionType *FTy = FunctionType::get(Int8PtrTy, Args, false);
	Function *F = Function::Create(
	FTy, GlobalValue::ExternalLinkage,
	"__cxa_find_matching_catch_" + Twine(NumClauses + 2), &M);
	FindMatchingCatches[NumClauses] = F;
	return F;
	}

	Function *
	WebAssemblyLowerEmscriptenExceptions::getInvokeWrapper(Module &M,
	InvokeInst *II) {
	SmallVector<Type *, 16> ArgTys;
	Value *Callee = II->getCalledValue();
	FunctionType *CalleeFTy;
	if (auto *F = dyn_cast<Function>(Callee))
	CalleeFTy = F->getFunctionType();
	else {
	auto *CalleeTy = dyn_cast<PointerType>(Callee->getType())->getElementType();
	CalleeFTy = dyn_cast<FunctionType>(CalleeTy);
	}

	std::string Sig = getSignature(CalleeFTy);
	if (InvokeWrappers.find(Sig) != InvokeWrappers.end())
	return InvokeWrappers[Sig];

	// Put the pointer to the callee as first argument
	ArgTys.push_back(PointerType::getUnqual(CalleeFTy));
	// Add argument types
	ArgTys.append(CalleeFTy->param_begin(), CalleeFTy->param_end());

	FunctionType *FTy = FunctionType::get(CalleeFTy->getReturnType(), ArgTys,
	CalleeFTy->isVarArg());
	Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage,
	"__invoke_" + Sig, &M);
	InvokeWrappers[Sig] = F;
	return F;
	}

	bool WebAssemblyLowerEmscriptenExceptions::runOnModule(Module &M) {
	LLVMContext &C = M.getContext();
	IRBuilder<> Builder(C);
	IntegerType *Int1Ty = Builder.getInt1Ty();
	PointerType *Int8PtrTy = Builder.getInt8PtrTy();
	IntegerType *Int32Ty = Builder.getInt32Ty();
	Type *VoidTy = Builder.getVoidTy();

	// Create global variables __THREW__, threwValue, and tempRet0
	ThrewGV = new GlobalVariable(M, Int1Ty, false, GlobalValue::ExternalLinkage,
	Builder.getFalse(),
	createGlobalValueName(M, "__THREW__"));
	ThrewValueGV = new GlobalVariable(
	M, Int32Ty, false, GlobalValue::ExternalLinkage, Builder.getInt32(0),
	createGlobalValueName(M, "threwValue"));
	TempRet0GV = new GlobalVariable(
	M, Int32Ty, false, GlobalValue::ExternalLinkage, Builder.getInt32(0),
	createGlobalValueName(M, "tempRet0"));

	// Register __resumeException function
	FunctionType *ResumeFTy = FunctionType::get(VoidTy, Int8PtrTy, false);
	ResumeF = Function::Create(ResumeFTy, GlobalValue::ExternalLinkage,
	"__resumeException", &M);

	// Register llvm_eh_typeid_for function
	FunctionType *EHTypeIdTy = FunctionType::get(Int32Ty, Int8PtrTy, false);
	EHTypeIdF = Function::Create(EHTypeIdTy, GlobalValue::ExternalLinkage,
	"llvm_eh_typeid_for", &M);

	bool Changed = false;
	for (Function &F : M) {
	if (F.isDeclaration())
	continue;
	Changed \|= runOnFunction(F);
	}

	if (!Changed)
	return false;

	assert(!M.getNamedGlobal("setThrew") && "setThrew already exists");
	assert(!M.getNamedGlobal("setTempRet0") && "setTempRet0 already exists");

	// Create setThrew function
	SmallVector<Type *, 2> Params = {Int1Ty, Int32Ty};
	FunctionType *FTy = FunctionType::get(VoidTy, Params, false);
	Function *F =
	Function::Create(FTy, GlobalValue::ExternalLinkage, "setThrew", &M);
	Argument Arg1 = &(F->arg_begin());
	Argument Arg2 = &(++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);

	Builder.SetInsertPoint(EntryBB);
	Value *Threw = Builder.CreateLoad(ThrewGV, ThrewGV->getName() + ".val");
	Value *Cmp = Builder.CreateICmpEQ(Threw, Builder.getFalse(), "cmp");
	Builder.CreateCondBr(Cmp, ThenBB, EndBB);

	Builder.SetInsertPoint(ThenBB);
	Builder.CreateStore(Arg1, ThrewGV);
	Builder.CreateStore(Arg2, ThrewValueGV);
	Builder.CreateBr(EndBB);

	Builder.SetInsertPoint(EndBB);
	Builder.CreateRetVoid();

	// Create setTempRet0 function
	Params = {Int32Ty};
	FTy = FunctionType::get(VoidTy, Params, false);
	F = Function::Create(FTy, GlobalValue::ExternalLinkage, "setTempRet0", &M);
	F->arg_begin()->setName("value");
	EntryBB = BasicBlock::Create(C, "entry", F);
	Builder.SetInsertPoint(EntryBB);
	Builder.CreateStore(&*F->arg_begin(), TempRet0GV);
	Builder.CreateRetVoid();

	return true;
	}

	bool WebAssemblyLowerEmscriptenExceptions::runOnFunction(Function &F) {
	Module &M = *F.getParent();
	LLVMContext &C = F.getContext();
	IRBuilder<> Builder(C);
	bool Changed = false;
	SmallVector<Instruction *, 64> ToErase;
	SmallPtrSet<LandingPadInst *, 32> LandingPads;
	bool AllowExceptions =
	areAllExceptionsAllowed() \|\| WhitelistSet.count(F.getName());

	for (BasicBlock &BB : F) {
	auto *II = dyn_cast<InvokeInst>(BB.getTerminator());
	if (!II)
	continue;
	Changed = true;
	LandingPads.insert(II->getLandingPadInst());
	Builder.SetInsertPoint(II);

	bool NeedInvoke = AllowExceptions && canThrow(II->getCalledValue());
	if (NeedInvoke) {
	// If we are calling a function that is noreturn, we must remove that
	// attribute. The code we insert here does expect it to return, after we
	// catch the exception.
	if (II->doesNotReturn()) {
	if (auto *F = dyn_cast<Function>(II->getCalledValue()))
	F->removeFnAttr(Attribute::NoReturn);
	AttributeSet NewAttrs = II->getAttributes();
	NewAttrs.removeAttribute(C, AttributeSet::FunctionIndex,
	Attribute::NoReturn);
	II->setAttributes(NewAttrs);
	}

	// Pre-invoke
	// __THREW__ = 0;
	Builder.CreateStore(Builder.getFalse(), ThrewGV);

	// Invoke function wrapper in JavaScript
	SmallVector<Value *, 16> CallArgs;
	// Put the pointer to the callee as first argument, so it can be called
	// within the invoke wrapper later
	CallArgs.push_back(II->getCalledValue());
	CallArgs.append(II->arg_begin(), II->arg_end());
	CallInst *NewCall = Builder.CreateCall(getInvokeWrapper(M, II), CallArgs);
	NewCall->takeName(II);
	NewCall->setCallingConv(II->getCallingConv());
	NewCall->setDebugLoc(II->getDebugLoc());

	// Because we added the pointer to the callee as first argument, all
	// argument attribute indices have to be incremented by one.
	SmallVector<AttributeSet, 8> AttributesVec;
	const AttributeSet &InvokePAL = II->getAttributes();
	CallSite::arg_iterator AI = II->arg_begin();
	unsigned i = 1; // Argument attribute index starts from 1
	for (unsigned e = II->getNumArgOperands(); i <= e; ++AI, ++i) {
	if (InvokePAL.hasAttributes(i)) {
	AttrBuilder B(InvokePAL, i);
	AttributesVec.push_back(AttributeSet::get(C, i + 1, B));
	}
	}
	// Add any return attributes.
	if (InvokePAL.hasAttributes(AttributeSet::ReturnIndex))
	AttributesVec.push_back(
	AttributeSet::get(C, InvokePAL.getRetAttributes()));
	// Add any function attributes.
	if (InvokePAL.hasAttributes(AttributeSet::FunctionIndex))
	AttributesVec.push_back(
	AttributeSet::get(C, InvokePAL.getFnAttributes()));
	// Reconstruct the AttributesList based on the vector we constructed.
	AttributeSet NewCallPAL = AttributeSet::get(C, AttributesVec);
	NewCall->setAttributes(NewCallPAL);

	II->replaceAllUsesWith(NewCall);
	ToErase.push_back(II);

	// Post-invoke
	// %__THREW__.val = __THREW__; __THREW__ = 0;
	Value *Threw = Builder.CreateLoad(ThrewGV, ThrewGV->getName() + ".val");
	Builder.CreateStore(Builder.getFalse(), ThrewGV);

	// Insert a branch based on __THREW__ variable
	Builder.CreateCondBr(Threw, II->getUnwindDest(), II->getNormalDest());

	} else {
	// This can't throw, and we don't need this invoke, just replace it with a
	// call+branch
	SmallVector<Value *, 16> CallArgs(II->arg_begin(), II->arg_end());
	CallInst *NewCall = Builder.CreateCall(II->getCalledValue(), CallArgs);
	NewCall->takeName(II);
	NewCall->setCallingConv(II->getCallingConv());
	NewCall->setDebugLoc(II->getDebugLoc());
	NewCall->setAttributes(II->getAttributes());
	II->replaceAllUsesWith(NewCall);
	ToErase.push_back(II);

	Builder.CreateBr(II->getNormalDest());

	// Remove any PHI node entries from the exception destination
	II->getUnwindDest()->removePredecessor(&BB);
	}
	}

	// Process resume instructions
	for (BasicBlock &BB : F) {
	// Scan the body of the basic block for resumes
	for (Instruction &I : BB) {
	auto *RI = dyn_cast<ResumeInst>(&I);
	if (!RI)
	continue;

	// Split the input into legal values
	Value *Input = RI->getValue();
	Builder.SetInsertPoint(RI);
	Value *Low = Builder.CreateExtractValue(Input, 0, "low");

	// Create a call to __resumeException function
	Value *Args[] = {Low};
	Builder.CreateCall(ResumeF, Args);

	// Add a terminator to the block
	Builder.CreateUnreachable();
	ToErase.push_back(RI);
	}
	}

	// Process llvm.eh.typeid.for intrinsics
	for (BasicBlock &BB : F) {
	for (Instruction &I : BB) {
	auto *CI = dyn_cast<CallInst>(&I);
	if (!CI)
	continue;
	const Function *Callee = CI->getCalledFunction();
	if (!Callee)
	continue;
	if (Callee->getIntrinsicID() != Intrinsic::eh_typeid_for)
	continue;

	Builder.SetInsertPoint(CI);
	CallInst *NewCI =
	Builder.CreateCall(EHTypeIdF, CI->getArgOperand(0), "typeid");
	CI->replaceAllUsesWith(NewCI);
	ToErase.push_back(CI);
	}
	}

	// Look for orphan landingpads, can occur in blocks with no predecesors
	for (BasicBlock &BB : F) {
	Instruction *I = BB.getFirstNonPHI();
	if (auto *LPI = dyn_cast<LandingPadInst>(I))
	LandingPads.insert(LPI);
	}

	// Handle all the landingpad for this function together, as multiple invokes
	// may share a single lp
	for (LandingPadInst *LPI : LandingPads) {
	Builder.SetInsertPoint(LPI);
	SmallVector<Value *, 16> FMCArgs;
	for (unsigned i = 0, e = LPI->getNumClauses(); i < e; ++i) {
	Constant *Clause = LPI->getClause(i);
	// As a temporary workaround for the lack of aggregate varargs support
	// in the interface between JS and wasm, break out filter operands into
	// their component elements.
	if (LPI->isFilter(i)) {
	ArrayType *ATy = cast<ArrayType>(Clause->getType());
	for (unsigned j = 0, e = ATy->getNumElements(); j < e; ++j) {
	Value *EV =
	Builder.CreateExtractValue(Clause, makeArrayRef(j), "filter");
	FMCArgs.push_back(EV);
	}
	} else
	FMCArgs.push_back(Clause);
	}

	// Create a call to __cxa_find_matching_catch_N function
	Function *FMCF = getFindMatchingCatch(M, FMCArgs.size());
	CallInst *FMCI = Builder.CreateCall(FMCF, FMCArgs, "fmc");
	Value *Undef = UndefValue::get(LPI->getType());
	Value *Pair0 = Builder.CreateInsertValue(Undef, FMCI, 0, "pair0");
	Value *TempRet0 =
	Builder.CreateLoad(TempRet0GV, TempRet0GV->getName() + "val");
	Value *Pair1 = Builder.CreateInsertValue(Pair0, TempRet0, 1, "pair1");

	LPI->replaceAllUsesWith(Pair1);
	ToErase.push_back(LPI);
	}

	// Erase everything we no longer need in this function
	for (Instruction *I : ToErase)
	I->eraseFromParent();

	return Changed;
	}