[WebAssembly] Add Wasm exception handling prepare pass

[aheejin]

Summary

This adds a new 'Wasm' exception handling mode to CodeGen backend, and a
WasmEHPrepare pass that adapts code to be used in WebAssembly exception
handling.

Ref: (Tentative) WebAssembly EH scheme for toolchain

[aheejin]

delete a stray line

[aheejin]

add a line in the test

[aheejin]

typo

[aheejin]

wasm_landingpad_context -> wasm_lpad_context

[aheejin]

Add an optimization: We don't store personality function address and LSDA
address at non-top-level landing pads (landing pads that are dominated by
another landing pad), because they have already been stored before.

[aheejin]

For the curious, here is in-progress work of WebAssembly EH scheme documentation, which will be merged to the official WebAssembly tool-convention repo later.

[dschuff]

lib/CodeGen/DwarfEHPrepare.cpp

52

If we implement resuming as as wasm rethrow, can we make the personality function or its wrapper resume by rethrowing, in cases where it would otherwise have returned _URC_CONTINUE_UNWIND? Then we actually could prune the unreachable resumes.

lib/CodeGen/WasmEHPrepare.cpp

35

Probably want to say "wasm VM" instead of V8 here and instead of "JavaScript Engine" down in line 38.

[aheejin]

JS engine -> VM

lib/CodeGen/DwarfEHPrepare.cpp

52

As we discussed with Karl,

1. rethrow only works within the same function, static scope.
2. Even if rethrow works dynamically within callees, it wouldn't work within the factored-out common code, so, it's tricky.

[aheejin]

Rebased to the tip of the svn.

[aheejin]

clang-tidy modernize

[aheejin]

@dschuff Do you think we can land this? This is not specifically related to the proposed spec change.

[aheejin]

+ Disabled storing personality function address at every landing pad
+ Removed hardcoding of '_Unwind_Resume' function name
+ Rebased to the tip of the svn

[aheejin]

The spec is planned to change significantly, so I will close this CL for now.

include/llvm/CodeGen/Passes.h

/// MachineDominanaceFrontier - This pass is a machine dominators analysis pass.
 
   /// createMachineVerifierPass - This pass verifies cenerated machine code
   /// instructions for correctness.
   ///
   FunctionPass *createMachineVerifierPass(const std::string& Banner);
 
   /// createDwarfEHPass - This pass mulches exception handling code into a form
   /// adapted to code generation.  Required if using dwarf exception handling.
-  FunctionPass *createDwarfEHPass();
+  FunctionPass *createDwarfEHPass(bool PruneUnreachableResumes=true);
 
   /// createWinEHPass - Prepares personality functions used by MSVC on Windows,
   /// in addition to the Itanium LSDA based personalities.
   FunctionPass *createWinEHPass();
 
   /// createSjLjEHPreparePass - This pass adapts exception handling code to use
   /// the GCC-style builtin setjmp/longjmp (sjlj) to handling EH control flow.
   ///
   FunctionPass *createSjLjEHPreparePass();
 
+  /// createWasmEHPreparePass - This pass adapts exception handling code to use
+  /// WebAssembly's exception handling scheme.
+  FunctionPass *createWasmEHPreparePass();
+
   /// LocalStackSlotAllocation - This pass assigns local frame indices to stack
   /// slots relative to one another and allocates base registers to access them
   /// when it is estimated by the target to be out of range of normal frame
   /// pointer or stack pointer index addressing.
   extern char &LocalStackSlotAllocationID;
 
   /// ExpandISelPseudos - This pass expands pseudo-instructions.
   extern char &ExpandISelPseudosID;

include/llvm/IR/IntrinsicsWebAssembly.td

 let TargetPrefix = "wasm" in {  // All intrinsics start with "llvm.wasm.".
 
 // Note that current_memory is not IntrNoMem because it must be sequenced with
 // respect to grow_memory calls.
 def int_wasm_current_memory : Intrinsic<[llvm_anyint_ty], [], [IntrReadMem]>;
 def int_wasm_grow_memory : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>], []>;
 
 // Exception handling intrinsics
-def int_wasm_throw: Intrinsic<[], [llvm_i32_ty, llvm_ptr_ty], [Throws]>;
-def int_wasm_rethrow: Intrinsic<[], [], [Throws]>;
 
+def int_wasm_throw
+    : Intrinsic<[], [ llvm_i32_ty, llvm_ptr_ty ], [ Throws, IntrNoReturn ]>;
+def int_wasm_rethrow : Intrinsic<[], [], [Throws, IntrNoReturn]>;
+// wasm.catch returns the pointer to the exception object caught by wasm 'catch'
+// instruction.
+def int_wasm_catch
+    : Intrinsic<[ llvm_ptr_ty ], [ llvm_i32_ty ], [ IntrHasSideEffects ]>;
+// 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_eh_landingpad_index: Intrinsic<[], [llvm_i32_ty], [IntrNoMem]>;
+// Returns LSDA address of the current function.
+def int_wasm_eh_lsda : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
 }

include/llvm/InitializePasses.h

 void initializeTypeBasedAAWrapperPassPass(PassRegistry&);
 void initializeUnifyFunctionExitNodesPass(PassRegistry&);
 void initializeUnpackMachineBundlesPass(PassRegistry&);
 void initializeUnreachableBlockElimLegacyPassPass(PassRegistry&);
 void initializeUnreachableMachineBlockElimPass(PassRegistry&);
 void initializeVerifierLegacyPassPass(PassRegistry&);
 void initializeVirtRegMapPass(PassRegistry&);
 void initializeVirtRegRewriterPass(PassRegistry&);
+void initializeWasmEHPreparePass(PassRegistry&);
 void initializeWholeProgramDevirtPass(PassRegistry&);
 void initializeWinEHPreparePass(PassRegistry&);
 void initializeWriteBitcodePassPass(PassRegistry&);
 void initializeWriteThinLTOBitcodePass(PassRegistry&);
 void initializeXRayInstrumentationPass(PassRegistry&);
 void initializeMIRCanonicalizerPass(PassRegistry &);
 
 } // end namespace llvm
 
 #endif // LLVM_INITIALIZEPASSES_H

include/llvm/MC/MCTargetOptions.h

 namespace llvm {
 
 enum class ExceptionHandling {
   None,     /// No exception support
   DwarfCFI, /// DWARF-like instruction based exceptions
   SjLj,     /// setjmp/longjmp based exceptions
   ARM,      /// ARM EHABI
   WinEH,    /// Windows Exception Handling
+  Wasm,     /// WebAssembly Exception Handling
 };
 
 enum class DebugCompressionType {
   None, /// No compression
   GNU,  /// zlib-gnu style compression
   Z,    /// zlib style complession
 };
 

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

case ExceptionHandling::WinEH:
     case WinEH::EncodingType::Invalid:
       break;
     case WinEH::EncodingType::X86:
     case WinEH::EncodingType::Itanium:
       ES = new WinException(this);
       break;
     }
     break;
+  case ExceptionHandling::Wasm:
+    // TODO Add Wasm EH
+    break;
   }
   if (ES)
     Handlers.push_back(HandlerInfo(ES, EHTimerName, EHTimerDescription,
                                    DWARFGroupName, DWARFGroupDescription));
   return false;
 }
 
 static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) {

lib/CodeGen/CMakeLists.txt

add_llvm_library(LLVMCodeGen
   TargetOptionsImpl.cpp
   TargetPassConfig.cpp
   TargetRegisterInfo.cpp
   TargetSchedule.cpp
   TargetSubtargetInfo.cpp
   TwoAddressInstructionPass.cpp
   UnreachableBlockElim.cpp
   VirtRegMap.cpp
+  WasmEHPrepare.cpp
   WinEHPrepare.cpp
   XRayInstrumentation.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/CodeGen
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/CodeGen/PBQP
 
   LINK_LIBS ${LLVM_PTHREAD_LIB}

lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeTailDuplicatePassPass(Registry);
   initializeTargetPassConfigPass(Registry);
   initializeTwoAddressInstructionPassPass(Registry);
   initializeUnpackMachineBundlesPass(Registry);
   initializeUnreachableBlockElimLegacyPassPass(Registry);
   initializeUnreachableMachineBlockElimPass(Registry);
   initializeVirtRegMapPass(Registry);
   initializeVirtRegRewriterPass(Registry);
+  initializeWasmEHPreparePass(Registry);
   initializeWinEHPreparePass(Registry);
   initializeXRayInstrumentationPass(Registry);
   initializeMIRCanonicalizerPass(Registry);
 }
 
 void LLVMInitializeCodeGen(LLVMPassRegistryRef R) {
   initializeCodeGen(*unwrap(R));
 }

lib/CodeGen/DwarfEHPrepare.cpp

 
 namespace {
 
   class DwarfEHPrepare : public FunctionPass {
     // RewindFunction - _Unwind_Resume or the target equivalent.
     Constant *RewindFunction = nullptr;
 
     DominatorTree *DT = nullptr;
     const TargetLowering *TLI = nullptr;
+    bool PruneUnreachableResumes;
 
     bool InsertUnwindResumeCalls(Function &Fn);
     Value *GetExceptionObject(ResumeInst *RI);
     size_t
     pruneUnreachableResumes(Function &Fn,
                             SmallVectorImpl<ResumeInst *> &Resumes,
                             SmallVectorImpl<LandingPadInst *> &CleanupLPads);
 
   public:
     static char ID; // Pass identification, replacement for typeid.
 
-    DwarfEHPrepare() : FunctionPass(ID) {}
+    DwarfEHPrepare(bool PruneUnreachableResumes = true)
+        : FunctionPass(ID), PruneUnreachableResumes(PruneUnreachableResumes) {}
 
     bool runOnFunction(Function &Fn) override;
 
     bool doFinalization(Module &M) override {
       RewindFunction = nullptr;
       return false;
     }
 

 INITIALIZE_PASS_BEGIN(DwarfEHPrepare, DEBUG_TYPE,
                       "Prepare DWARF exceptions", false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_END(DwarfEHPrepare, DEBUG_TYPE,
                     "Prepare DWARF exceptions", false, false)
 
-FunctionPass *llvm::createDwarfEHPass() { return new DwarfEHPrepare(); }
+FunctionPass *llvm::createDwarfEHPass(bool PruneUnreachableResumes) {
+  return new DwarfEHPrepare(PruneUnreachableResumes);
+}
 
 void DwarfEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<TargetPassConfig>();
   AU.addRequired<TargetTransformInfoWrapperPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
 }
 
 /// GetExceptionObject - Return the exception object from the value passed into
bool DwarfEHPrepare::InsertUnwindResumeCalls(Function &Fn) {
 
   // Check the personality, don't do anything if it's funclet-based.
   EHPersonality Pers = classifyEHPersonality(Fn.getPersonalityFn());
   if (isFuncletEHPersonality(Pers))
     return false;
 
   LLVMContext &Ctx = Fn.getContext();
 
-  size_t ResumesLeft = pruneUnreachableResumes(Fn, Resumes, CleanupLPads);
+  size_t ResumesLeft = Resumes.size();
+  if (PruneUnreachableResumes) {
+    ResumesLeft = pruneUnreachableResumes(Fn, Resumes, CleanupLPads);
     if (ResumesLeft == 0)
       return true; // We pruned them all.
+  }
 
   // Find the rewind function if we didn't already.
   if (!RewindFunction) {
     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                           Type::getInt8PtrTy(Ctx), false);
     const char *RewindName = TLI->getLibcallName(RTLIB::UNWIND_RESUME);
     RewindFunction = Fn.getParent()->getOrInsertFunction(RewindName, FTy);
   }

lib/CodeGen/TargetPassConfig.cpp

case ExceptionHandling::ARM:
     break;
   case ExceptionHandling::WinEH:
     // We support using both GCC-style and MSVC-style exceptions on Windows, so
     // add both preparation passes. Each pass will only actually run if it
     // recognizes the personality function.
     addPass(createWinEHPass());
     addPass(createDwarfEHPass());
     break;
+  case ExceptionHandling::Wasm:
+    addPass(createWasmEHPreparePass());
+    // We shouldn't prune unreachable resumes in Wasm EH, because unwinding
+    // stops at every call frame with a landing pad.
+    addPass(createDwarfEHPass(false));
+    break;
   case ExceptionHandling::None:
     addPass(createLowerInvokePass());
 
     // The lower invoke pass may create unreachable code. Remove it.
     addPass(createUnreachableBlockEliminationPass());
     break;
   }
 }

lib/CodeGen/WasmEHPrepare.cpp

+//===-- WasmEHPrepare - Prepare excepton handling for WebAssembly --------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This transformation is designed for use by code generators which use
+// WebAssembly exception handling scheme.
+//
+// * WebAssembly EH instructions
+// WebAssembly's try and catch instructions are structured as follows:
+// try
+//   instruction*
+// catch (C++ tag)
+//   instruction*
+// ...
+// catch_all
+//   instruction*
+// try_end
+//
+// A catch instruction in WebAssembly does not correspond to a C++ catch clause.
+// In WebAssembly, there is a single catch instruction for all C++ exceptions.
+// There can be more catch instructions for exceptions in other languages, but
+// they are not generated for now. catch_all catches all exceptions including
+// foreign ones, but this is not genereated for the current version of
+// implementation yet as well. In this pass we generate a call to wasm.catch
+// intrinsic, which is going to be lowered to a WebAssembly catch instruction at
+// instruction selection phase.
+//
+// * libunwind
+// In WebAssembly EH, the VM is responsible for unwinding stack once an
+// exception is thrown. After stack is unwound, the control flow is transfered
+// to WebAssembly 'catch' instruction, which returns a caught exception object.
+//
+// Unwinding stack is not done by libunwind but the VM, so the personality
+// function in libcxxabi cannot be called from libunwind during the unwinding
+// process. So after returned from a catch instruction, which means stack was
+// unwound by the VM, we actively call a wrapper function in libunwind that in
+// turn calls the real personality function.
+//
+// In Itanium EH, if the personality function decides there is no matching catch
+// cluase in a call frame and there is no cleanup action to perform, the
+// unwinder doesn't stop there and continues unwinding. But in Wasm EH, the
+// unwinder stops at every call frame with a landing pad, after which the
+// personality function is called actively from the code.
+//
+// In libunwind/include/Unwind-wasm.c, we have this struct that serves as a
+// communincation channel between user code and the personality function in
+// libcxxabi.
+//
+// struct _Unwind_LandingPadContext {
+//   uintptr_t lpad_index;
+//   uintptr_t lsda;
+//   uintptr_t selector;
+// };
+// struct _Unwind_LandingPadContext __wasm_lpad_context = ...;
+//
+// And this wrapper in libunwind calls the personality function.
+//
+// _Unwind_Reason_Code _Unwind_CallPersonality(void *exception_ptr) {
+//   struct _Unwind_Exception *exception_obj =
+//       (struct _Unwind_Exception *)exception_ptr;
+//   _Unwind_Reason_Code ret = __gxx_personality_v0(
+//       1, _UA_CLEANUP_PHASE, exception_obj->exception_class, exception_obj,
+//       (struct _Unwind_Context *)__wasm_lpad_context);
+//   return ret;
+// }
+//
+// * This pass does the following things:
+//
+// 1. Insert a call to wasm.eh.landingpad.index() before every invoke
+//    instruction. Each landing pad has its own index starting from 0, and the
+//    argument to wasm.eh.landingpad.index() is the index of the landing pad
+//    each invoke instruction unwinds to.
+//    e.g.
+//    call void wasm.eh.landingpad.index(index);
+//    invoke void @foo() ... // original invoke inst
+//
+//    wasm.eh.landingpad.index() function is lowered later to pass information
+//    to LSDA generator.
+//
+// 2. Adds following code after every landingpad instruction:
+//    (In C-style pseudocode)
+//
+//    {old_exn, old_selector} = landingpad .. // original landingpad inst
+//    void *exn = wasm.catch(0);
+//    __wasm_lpad_context.lpad_index = index;
+//    __wasm_lpad_context.lsda = wasm.eh.lsda();
+//    _Unwind_CallPersonality(exn);
+//    int selector = __wasm.landingpad_context.selector;
+//    // use {exn, selector} instead hereafter
+//
+//    wasm.catch() function returns a caught exception object. We pass a landing
+//    pad index, and the address of LSDA for the current function to the wrapper
+//    function _Unwind_CallPersonality in libunwind, which calls a personality
+//    function. And we retrieve the selector after it returns. The landingpad
+//    instruction will be removed at instruction selection phase, and {exn,
+//    selector} will replace its return value.
+//
+//===----------------------------------------------------------------------===//
+
+// TODO CATCH instruction semantics may change in the future
+// TODO Can we not store LSDA address every time and make libcxxabi compute it?
+
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/TargetLowering.h"
+#include "llvm/CodeGen/TargetPassConfig.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/Pass.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
+using namespace llvm;
+
+#define DEBUG_TYPE "wasmehprepare"
+
+namespace {
+class WasmEHPrepare : public FunctionPass {
+  Type *LPadContextTy = nullptr; // type of 'struct _Unwind_LandingPadContext'
+  GlobalVariable *LPadContextGV = nullptr; // __wasm_lpad_context
+
+  // Field addresses of struct _Unwind_LandingPadContext
+  Value *LPadIndexField = nullptr;   // lpad_index field
+  Value *LSDAField = nullptr;        // lsda field
+  Value *SelectorField = nullptr;    // selector
+
+  Function *CatchF = nullptr;           // wasm.catch() intrinsic
+  Function *LPadIndexF = nullptr;       // wasm.eh.landingpad.index() intrinsic
+  Function *LSDAF = nullptr;            // wasm.eh.lsda() intrinsic
+  Function *CallPersonalityF = nullptr; // _Unwind_CallPersonality() wrapper
+
+  void prepareLandingPad(BasicBlock *BB, unsigned Index, bool IsTopLevelLPad);
+  void substituteLPadValues(LandingPadInst *LPI, Value *Exn, Value *Selector);
+
+public:
+  static char ID; // Pass identification, replacement for typeid
+
+  WasmEHPrepare() : FunctionPass(ID) {}
+
+  bool doInitialization(Module &M) override;
+  bool runOnFunction(Function &F) override;
+
+  StringRef getPassName() const override {
+    return "WebAssembly Exception handling preparation";
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addRequired<TargetPassConfig>();
+    AU.addRequired<DominatorTreeWrapperPass>();
+  }
+};
+} // end anonymous namespace
+
+char WasmEHPrepare::ID = 0;
+INITIALIZE_PASS(WasmEHPrepare, DEBUG_TYPE, "Prepare WebAssembly exceptions",
+                false, false);
+
+FunctionPass *llvm::createWasmEHPreparePass() { return new WasmEHPrepare(); }
+
+bool WasmEHPrepare::doInitialization(Module &M) {
+  IRBuilder<> IRB(M.getContext());
+  LPadContextTy = StructType::get(IRB.getInt32Ty(),   // lpad_index
+                                  IRB.getInt8PtrTy(), // lsda
+                                  IRB.getInt32Ty()    // selector
+  );
+  return false;
+}
+
+bool WasmEHPrepare::runOnFunction(Function &F) {
+  SmallVector<BasicBlock *, 16> LPads;
+  for (BasicBlock &BB : F) {
+    if (BB.isEHPad())
+      LPads.push_back(&BB);
+  }
+
+  if (LPads.empty())
+    return false;
+
+  assert(F.hasPersonalityFn() && "Personality function not found");
+
+  Module &M = *F.getParent();
+  IRBuilder<> IRB(F.getContext());
+
+  // wasm.catch() intinsic. Will be lowered to WebAssmebly 'catch' instruction.
+  CatchF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_catch);
+  // wasm.eh.landingpad.index() intrinsic, which is to specify landingpad index
+  LPadIndexF =
+      Intrinsic::getDeclaration(&M, Intrinsic::wasm_eh_landingpad_index);
+  // wasm.eh.lsda() intrinsic. Returns the address of LSDA table for the current
+  // function.
+  LSDAF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_eh_lsda);
+  // _Unwind_CallPersonality() wrapper function, which calls the personality
+  CallPersonalityF = cast<Function>(M.getOrInsertFunction(
+      "_Unwind_Wasm_CallPersonality", IRB.getInt32Ty(), IRB.getInt8PtrTy()));
+
+  // We may need to generate calls to _Unwind_Resume in CFGStackify pass in
+  // backend. Insert the function declaration now.
+  const TargetMachine &TM =
+      getAnalysis<TargetPassConfig>().getTM<TargetMachine>();
+  const TargetLowering *TLI = TM.getSubtargetImpl(F)->getTargetLowering();
+  FunctionType *FTy =
+      FunctionType::get(IRB.getVoidTy(), IRB.getInt8PtrTy(), false);
+  const char *RewindName = TLI->getLibcallName(RTLIB::UNWIND_RESUME);
+  F.getParent()->getOrInsertFunction(RewindName, FTy);
+
+  // __wasm_lpad_context global variable
+  LPadContextGV = cast<GlobalVariable>(
+      M.getOrInsertGlobal("__wasm_lpad_context", LPadContextTy));
+  LPadIndexField = IRB.CreateConstGEP2_32(LPadContextTy, LPadContextGV, 0, 0,
+                                          "lpad_index_gep");
+  LSDAField =
+      IRB.CreateConstGEP2_32(LPadContextTy, LPadContextGV, 0, 1, "lsda_gep");
+  SelectorField = IRB.CreateConstGEP2_32(LPadContextTy, LPadContextGV, 0, 2,
+                                         "selector_gep");
+
+  // Calculate top-level landing pads: landing pads that do not dominated by any
+  // of other landing pads.
+  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  SmallPtrSet<BasicBlock *, 16> TopLevelLPads;
+  DomTreeNode *Root = DT.getRootNode();
+  SmallVector<DomTreeNode *, 8> WL;
+  WL.push_back(Root);
+  while (!WL.empty()) {
+    DomTreeNode *N = WL.pop_back_val();
+    if (N->getBlock()->isEHPad())
+      TopLevelLPads.insert(N->getBlock());
+    else
+      WL.append(N->begin(), N->end());
+  }
+
+  for (unsigned I = 0, E = LPads.size(); I != E; ++I)
+    prepareLandingPad(LPads[I], I, TopLevelLPads.count(LPads[I]) > 0);
+
+  return true;
+}
+
+void WasmEHPrepare::prepareLandingPad(BasicBlock *BB, unsigned Index,
+                                      bool IsTopLevelLPad) {
+  assert(BB->isEHPad() && "BB is not a landing pad!");
+  Function *F = BB->getParent();
+  LandingPadInst *LPI = BB->getLandingPadInst();
+  IRBuilder<> IRB(F->getContext());
+
+  // Create a call to wasm.eh.landingpad.index intrinsic before every invoke
+  // instruction that has this BB as its unwind destination. This is to create a
+  // map of <landingpad BB, landingpad index> in SelectionDAG, which is to be
+  // used to create a map of <landingpad EH label, landingpad index> in
+  // SelectionDAGISel, again which is to be used in EHStreamer to emit LSDA
+  // tables.
+  for (BasicBlock *Pred : predecessors(BB)) {
+    auto *II = dyn_cast<InvokeInst>(Pred->getTerminator());
+    assert(II && "Landingpad's predecessor does not end with invoke");
+    IRB.SetInsertPoint(II);
+    IRB.CreateCall(LPadIndexF, IRB.getInt32(Index));
+  }
+
+  IRB.SetInsertPoint(&*BB->getFirstInsertionPt());
+  // The argument to wasm.catch() is the tag for C++ exceptions, which we set to
+  // 0 for this module.
+  ConstantInt *CppTag = IRB.getInt32(0);
+  // void *exn = wasm.catch(0);
+  Instruction *Exn = IRB.CreateCall(CatchF, CppTag, "exn");
+
+  // __wasm_lpad_context.lpad_index = index;
+  IRB.CreateStore(IRB.getInt32(Index), LPadIndexField, true);
+
+  // If this is not a top level landing pad, i.e., there is another landing pad
+  // that dominates this landing pad, we don't need to store LSDA address again,
+  // because they are the same throughout the function and have been already
+  // stored before.
+  if (IsTopLevelLPad)
+    // __wasm_lpad_context.lsda = wasm.eh.lsda();
+    IRB.CreateStore(IRB.CreateCall(LSDAF), LSDAField, true);
+  // _Unwind_CallPersonality(exn);
+  IRB.CreateCall(CallPersonalityF, Exn);
+  // int selector = __wasm.landingpad_context.selector;
+  Instruction *Selector = IRB.CreateLoad(SelectorField, "selector");
+  substituteLPadValues(LPI, Exn, Selector);
+}
+
+void WasmEHPrepare::substituteLPadValues(LandingPadInst *LPI, Value *Exn,
+                                         Value *Selector) {
+  SmallVector<Value *, 8> UseWorkList(LPI->user_begin(), LPI->user_end());
+  while (!UseWorkList.empty()) {
+    Value *V = UseWorkList.pop_back_val();
+    auto *EVI = dyn_cast<ExtractValueInst>(V);
+    if (!EVI)
+      continue;
+    if (EVI->getNumIndices() != 1)
+      continue;
+    if (*EVI->idx_begin() == 0)
+      EVI->replaceAllUsesWith(Exn);
+    else if (*EVI->idx_begin() == 1)
+      EVI->replaceAllUsesWith(Selector);
+    if (EVI->use_empty())
+      EVI->eraseFromParent();
+  }
+
+  if (LPI->use_empty())
+    return;
+
+  // There are still some uses of LPI. Construct an aggregate with the exception
+  // values and replace the LPI with that aggregate.
+  Type *LPadType = LPI->getType();
+  Value *LPadVal = UndefValue::get(LPadType);
+  auto *SelI = cast<Instruction>(Selector);
+  IRBuilder<> Builder(SelI->getParent(), std::next(SelI->getIterator()));
+  LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
+  LPadVal = Builder.CreateInsertValue(LPadVal, Selector, 1, "lpad.val");
+  LPI->replaceAllUsesWith(LPadVal);
+}

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCAsmInfo.cpp

WebAssemblyMCAsmInfoELF::WebAssemblyMCAsmInfoELF(const Triple &T) {
   Data64bitsDirective = "\t.int64\t";
 
   AlignmentIsInBytes = false;
   COMMDirectiveAlignmentIsInBytes = false;
   LCOMMDirectiveAlignmentType = LCOMM::Log2Alignment;
 
   SupportsDebugInformation = true;
 
-  // For now, WebAssembly does not support exceptions.
-  ExceptionsType = ExceptionHandling::None;
+  ExceptionsType = ExceptionHandling::Wasm;
 
   // TODO: UseIntegratedAssembler?
 
   // WebAssembly's stack is never executable.
   UsesNonexecutableStackSection = false;
 }
 
 WebAssemblyMCAsmInfo::~WebAssemblyMCAsmInfo() {}
WebAssemblyMCAsmInfo::WebAssemblyMCAsmInfo(const Triple &T) {
   Data64bitsDirective = "\t.int64\t";
 
   AlignmentIsInBytes = false;
   COMMDirectiveAlignmentIsInBytes = false;
   LCOMMDirectiveAlignmentType = LCOMM::Log2Alignment;
 
   SupportsDebugInformation = true;
 
-  // For now, WebAssembly does not support exceptions.
-  ExceptionsType = ExceptionHandling::None;
+  ExceptionsType = ExceptionHandling::Wasm;
 
   // TODO: UseIntegratedAssembler?
 }

test/CodeGen/WebAssembly/wasmehprepare.ll

+; RUN: opt < %s -wasmehprepare -S | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; CHECK: @__wasm_lpad_context = external global { i32, i8*, i32 }
+
+@_ZTIi = external constant i8*
+
+; There are two landing pads: one landing pad has two invokes as its
+; predecessors, and the other has one.
+define void @test1() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+; CHECK-LABEL: @test1()
+entry:
+  invoke void @foo()
+          to label %invoke.cont unwind label %lpad
+; CHECK: entry:
+; CHECK-NEXT: call void @llvm.wasm.eh.landingpad.index(i32 0)
+
+invoke.cont:                                      ; preds = %entry
+  invoke void @foo()
+          to label %try.cont unwind label %lpad
+; CHECK: invoke.cont:
+; CHECK-NEXT: call void @llvm.wasm.eh.landingpad.index(i32 0)
+
+lpad:                                             ; preds = %invoke.cont, %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)
+  call void @__cxa_end_catch()
+  br label %try.cont
+; CHECK: lpad:
+; CHECK: store volatile i32 0, i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 0)
+
+try.cont:                                         ; preds = %invoke.cont, %lpad
+  invoke void @foo()
+          to label %try.cont6 unwind label %lpad2
+; CHECK: try.cont:
+; CHECK-NEXT: call void @llvm.wasm.eh.landingpad.index(i32 1)
+
+lpad2:                                            ; preds = %try.cont
+  %4 = landingpad { i8*, i32 }
+          catch i8* bitcast (i8** @_ZTIi to i8*)
+  %5 = extractvalue { i8*, i32 } %4, 0
+  %6 = extractvalue { i8*, i32 } %4, 1
+  %7 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
+  %matches = icmp eq i32 %6, %7
+  br i1 %matches, label %catch4, label %eh.resume
+; CHECK: lpad2:
+; CHECK-NEXT: landingpad
+; CHECK-NEXT: catch
+; CHECK-NEXT: %[[EXN:.*]] = call i8* @llvm.wasm.catch(i32 0)
+; CHECK-NEXT: store volatile i32 1, i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 0)
+; CHECK-NEXT: %[[LSDA:.*]] = call i8* @llvm.wasm.eh.lsda()
+; CHECK-NEXT: store volatile i8* %[[LSDA]], i8** getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 1)
+; CHECK-NEXT: call i32 @_Unwind_Wasm_CallPersonality(i8* %[[EXN]])
+; 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]]
+
+catch4:                                           ; preds = %lpad2
+  %8 = call i8* @__cxa_begin_catch(i8* %5)
+  %9 = bitcast i8* %8 to i32*
+  %10 = load i32, i32* %9, align 4
+  call void @__cxa_end_catch()
+  br label %try.cont6
+; CHECK: catch4:
+; CHECK-NEXT: call i8* @__cxa_begin_catch(i8* %[[EXN]])
+
+try.cont6:                                        ; preds = %try.cont, %catch4
+  ret void
+
+eh.resume:                                        ; preds = %lpad2
+  %lpad.val = insertvalue { i8*, i32 } undef, i8* %5, 0
+  %lpad.val9 = insertvalue { i8*, i32 } %lpad.val, i32 %6, 1
+  resume { i8*, i32 } %lpad.val9
+; CHECK: eh.resume:
+; CHECK-NEXT: %[[VAL:.*]] = insertvalue { i8*, i32 } undef, i8* %[[EXN]], 0
+; CHECK-NEXT: %[[VAL2:.*]] = insertvalue { i8*, i32 } %[[VAL]], i32 %[[SELECTOR]], 1
+; CHECK-NEXT: resume { i8*, i32 } %[[VAL2]]
+}
+
+; Optimization test: non-top-level landing pads should not store LSDA address
+; again unnecessarily.
+define void @test2() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+; CHECK-LABEL: @test2()
+entry:
+  invoke void @foo()
+          to label %try.cont unwind label %lpad
+
+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) #3
+  invoke void @foo()
+          to label %invoke.cont2 unwind label %lpad1
+; CHECK: lpad:
+; CHECK-NEXT: landingpad
+; CHECK-NEXT: catch
+; CHECK-NEXT: @llvm.wasm.catch
+; CHECK-NEXT: store volatile i32 0
+; CHECK-NEXT: @llvm.wasm.eh.lsda
+; CHECK-NEXT: store volatile i8*
+; CHECK-NEXT: call i32 @_Unwind_Wasm_CallPersonality
+
+invoke.cont2:                                     ; preds = %lpad
+  call void @__cxa_end_catch()
+  br label %try.cont
+
+try.cont:                                         ; preds = %entry, %invoke.cont2
+  ret void
+
+lpad1:                                            ; preds = %lpad
+  %4 = landingpad { i8*, i32 }
+          cleanup
+  %5 = extractvalue { i8*, i32 } %4, 0
+  %6 = extractvalue { i8*, i32 } %4, 1
+  invoke void @__cxa_end_catch()
+          to label %eh.resume unwind label %terminate.lpad
+; CHECK: lpad1:
+; CHECK-NEXT: landingpad
+; CHECK-NEXT: cleanup
+; CHECK-NEXT: @llvm.wasm.catch
+; CHECK-NEXT: store volatile i32 1
+; CHECK-NEXT: call i32 @_Unwind_Wasm_CallPersonality
+
+eh.resume:                                        ; preds = %lpad1
+  %lpad.val = insertvalue { i8*, i32 } undef, i8* %5, 0
+  %lpad.val5 = insertvalue { i8*, i32 } %lpad.val, i32 %6, 1
+  resume { i8*, i32 } %lpad.val5
+
+terminate.lpad:                                   ; preds = %lpad1
+  %7 = landingpad { i8*, i32 }
+          catch i8* null
+  %8 = extractvalue { i8*, i32 } %7, 0
+  call void @__clang_call_terminate(i8* %8)
+  unreachable
+; CHECK: terminate.lpad:
+; CHECK-NEXT: landingpad
+; CHECK-NEXT: catch
+; CHECK-NEXT: @llvm.wasm.catch
+; CHECK-NEXT: store volatile i32 2
+; CHECK-NEXT: call i32 @_Unwind_Wasm_CallPersonality
+}
+
+declare void @foo()
+declare i32 @__gxx_personality_v0(...)
+declare i8* @__cxa_begin_catch(i8*)
+declare void @__cxa_end_catch()
+declare i32 @llvm.eh.typeid.for(i8*)
+declare void @__clang_call_terminate(i8*)
+
+; CHECK-DAG: declare i8* @llvm.wasm.catch(i32)
+; CHECK-DAG: declare void @llvm.wasm.eh.landingpad.index(i32)
+; CHECK-DAG: declare i8* @llvm.wasm.eh.lsda()
+; CHECK-DAG: declare i32 @_Unwind_Wasm_CallPersonality(i8*)

tools/opt/opt.cpp

int main(int argc, char **argv) {
   initializeSjLjEHPreparePass(Registry);
   initializePreISelIntrinsicLoweringLegacyPassPass(Registry);
   initializeGlobalMergePass(Registry);
   initializeInterleavedAccessPass(Registry);
   initializeEntryExitInstrumenterPass(Registry);
   initializePostInlineEntryExitInstrumenterPass(Registry);
   initializeUnreachableBlockElimLegacyPassPass(Registry);
   initializeExpandReductionsPass(Registry);
+  initializeWasmEHPreparePass(Registry);
   initializeWriteBitcodePassPass(Registry);
 
 #ifdef LINK_POLLY_INTO_TOOLS
   polly::initializePollyPasses(Registry);
 #endif
 
   cl::ParseCommandLineOptions(argc, argv,
     "llvm .bc -> .bc modular optimizer and analysis printer\n");