[WebAssembly] Add Wasm exception handling prepare pass

[aheejin]

Summary

This adds a pass that transforms a program to be prepared for Wasm
exception handling. This patch is based on the previous wasm EH proposal
and makes use of Windows EH instructions.

[majnemer]

include/llvm/CodeGen/Passes.h

328

clang-format this

include/llvm/IR/IntrinsicsWebAssembly.td

42–61

Please add some white space before each comment block, it is tough to read this.

lib/CodeGen/WasmEHPrepare.cpp

181–184

No need to brace.

289–292

What if this landing pad is dominated by two landing pads which are both top-level?

[aheejin]

• Address comments

[aheejin]

lib/CodeGen/WasmEHPrepare.cpp

289–292

It's OK because the LSDA address is the same throughout a function. Actually we can store it just once in the entry block and that would be sufficient, but that would incur additional cost even when no exception occurs, so I didn't do that.

[aheejin]

• rebase

[aheejin]

• comment line wrapping fix

[dschuff]

include/llvm/IR/IntrinsicsWebAssembly.td

43

This description is a little confusing. Maybe it should start with a high-level description of its semantics in terms of LLVM IR (i.e. without reference to the wasm primitives that implement it), and then after that put this description of how it's lowered.

lib/CodeGen/DwarfEHPrepare.cpp

209 ↗

(On Diff #136956)

This can go inside the pruneUnreachableresumes conditional since it's only used there.

lib/CodeGen/TargetPassConfig.cpp

662

this could be addPass(createDwarfEHPass(/*PruneUnreachableResumes=*/false) to make it more greppable.

lib/CodeGen/WasmEHPrepare.cpp

17

I assume the actual value of the index is a literal in the generated IR, and is assigned by this pass?

38

why not just delete it here from LLVM IR now that it's dead? or does it also get lowered somehow?

55

->represent a thrown exception

108

maybe put a TODO here to make a way to model the exception_ref in C++ so we can move more of the generated code into libraries.

196

Could these getDeclarations, getOrInsertFunctions, GlobalVariable fields etc be moved to doInitialization? Or maybe all except the one that requires the TargetMachine?

275

Could just use cast instead of dyn_cast and use its builtin assert.

286

could be /*isVolatile=*/true for readability. For that matter, why volatile?

[aheejin]

Will defer landing this after we sort out how WinEH might affect this.

[aheejin]

• Rebased onto master
• Set personality function call as nothrow
• Address previous comments

include/llvm/IR/IntrinsicsWebAssembly.td

43

This part will go away when we switch to windows EH instructions.

lib/CodeGen/DwarfEHPrepare.cpp

209 ↗

(On Diff #136956)

After we switch to windows EH, we don't need this anymore.

lib/CodeGen/TargetPassConfig.cpp

662

After we switch to windows EH, we don't need this anymore.

lib/CodeGen/WasmEHPrepare.cpp

17

Yes, it is generated by this pass, assigning an integer from 0 when traversing eh pads.

38

Landingpad instructions are lowered in [[ https://github.com/llvm-mirror/llvm/blob/b273503311ade5f98f2879195ed9c5655c3fff1b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp#L2468-L2517 | SelectionDAG::visitLandingPad ]], so we needed that by then. But anyway, after we switch to winEH we are not gonna have landingpads anymore; instead we are gonna have catchpads and cleanuppads.

55

Done.. but this part is gonna change anyway.

108

If we switch to winEH, we don't need it for now; will do it once we get to use except_ref later.

196

Done. I initially put them in runOnFunction because I didn't want to insert them if the program does not use exceptions thus has no landing pad. But they are gonna be deleted anyway at the end if unused, so I guess it's fine to move.

286

I didn't want to make them optimized away, so I thought setting isVolatile to true would be safer, no?

[aheejin]

This will change significantly due to switching to winEH instructions, which hasn't been applied yet. The previous patch just addresses existing comments.

[aheejin]

• Deleted debugging printf lines that was uploaded by mistake

[aheejin]

• Now Wasm EH uses WinEH instructions (catchswitch, catchpad/ret and cleanupad/ret) - Wasm EH runs WinEHPrepare before WasmEHPrepare, with a flag that it only demotes PHIs in catchswitch blocks.
• Go back to the previous Wasm EH proposal
• Moved a call to wasm.landingpad.index() intrinsic from invoke blocks to EH pad blocks, which will be more intuitive
• Add DemoteCatchSwitchOnly option to WinEHPrepare for Wasm EH
• Some cosmetic changes
• Rebase

[aheejin]

I messed up diff in last commit; fixing that

[aheejin]

• Cosmetic change

[aheejin]

Messed up diff again..

[aheejin]

• Extract personality function stuff to D45559
• Rebase

[aheejin]

• clang-tidy

[dschuff]

lib/CodeGen/WasmEHPrepare.cpp

64

probably worth making this "foreign exceptions (e.g. JavaScript)" since that's the expected case.

70

s/"stack"/"the stack" in most of the uses in this comment block.

218

could be else if

299

I still don't see why these stores need to be volatile. They store to a global so they shouldn't be touched before linking, and when the optimizer can see the uses, then it should do the right thing anyway?

lib/CodeGen/WinEHPrepare.cpp

54

Why do catchswitch phis need to be removed if we don't outline any funclets?

[aheejin]

• Address comments

lib/CodeGen/WinEHPrepare.cpp

54

Because catchswitch BBs are removed, or more precisely, not copied to MachineBasicBlock in ISel.

[aheejin]

lib/CodeGen/WinEHPrepare.cpp

54

The code that skips catchswitch blocks is here.

[dschuff]

The Wasm code looks good with the one comment so LGTM if @majnemer is OK with the modification to WinEHPrepare.

lib/CodeGen/WasmEHPrepare.cpp

196

Oh, that's a good point; I think you had it right the first time and that it does make sense not to unnecessarily add the globals (even if the cost is a bit of redundancy). Can you put it back? (sorry!)

[aheejin]

• Move stuff out of doInitialization again

[majnemer]

lib/CodeGen/WasmEHPrepare.cpp

186–188

I'd save and reuse BB.getFirstNonPHI.

270–276

What if BB branches to a block which calls wasm.get.exception? What if two different catchpads branch to a block which calls wasm.get.exception? ISTM that you might want to give it the token of the catchpad/cleanuppad somehow?

[aheejin]

• Address comments

[aheejin]

lib/CodeGen/WasmEHPrepare.cpp

270–276

Oh, I haven't thought about that possibility.. I kind of assumed that wasm.get.exception and wasm.get.selector intrinsics cannot be reordered past a catchpad's terminator because [[ https://github.com/llvm-mirror/llvm/blob/0ec6e3688b87112c68c882be89e59a7f6c1a0382/include/llvm/IR/IntrinsicsWebAssembly.td#L45-L47 | they are marked as IntrHasSideEffects ]]. Is this assumption wrong?

And can I attach a funclet bundle to function calls that are marked as nounwind? Looks like CodeGenFunction::getBundlesForFunclet function does not add a funclet bundle operand in case the callee cannot throw. I guess I still manually can add a funclet operand bundle though. Did you mean that?

[majnemer]

lib/CodeGen/WasmEHPrepare.cpp

270–276

I don't think they will get reordered past a catchret. However, I don't see anything that prevents:

bb0:
  catchpad []
  br cont

cont:
  wasm.get.exception

or

bb0:
  catchpad []
  br common

bb1:
  catchpad []
  br common

common:
  wasm.get.exception

Instead of attaching a funclet bundle to the intrinsic call, I'd do what the int_coro_* family of intrinsics do and pass the token as an argument to wasm.get.exception/wasm.get.selector.

Then, it is as easy as walking all the users of the catchpad token to find which wasm.get.exception/wasm.get.selector you need to replace.

[aheejin]

• Make wasm.get.exception/selector intrinsics take a token argument

lib/CodeGen/WasmEHPrepare.cpp

270–276

Thank you! That's a good point I have't thought about. I updated D44931 accordingly as well.

[aheejin]

• Set personality function call wrapper as nothrow

[aheejin]

@dschuff Are you OK with my latest change?

[dschuff]

Yes, still LGTM

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();
 
   /// createWinEHPass - Prepares personality functions used by MSVC on Windows,
   /// in addition to the Itanium LSDA based personalities.
-  FunctionPass *createWinEHPass();
+  FunctionPass *createWinEHPass(bool DemoteCatchSwitchPHIOnly = false);
 
   /// createSjLjEHPreparePass - This pass adapts exception handling code to use
   /// the GCC-style builtin setjmp/longjmp (sjlj) to handling EH control flow.
   ///
   FunctionPass *createSjLjEHPreparePass();
 
+  /// createWasmEHPass - This pass adapts exception handling code to use
+  /// WebAssembly's exception handling scheme.
+  FunctionPass *createWasmEHPass();
+
   /// 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

 //===----------------------------------------------------------------------===//
 // Exception handling intrinsics
 //===----------------------------------------------------------------------===//
 
 // throw / rethrow
 def int_wasm_throw : Intrinsic<[], [llvm_i32_ty, llvm_ptr_ty],
                                [Throws, IntrNoReturn]>;
 def int_wasm_rethrow : Intrinsic<[], [], [Throws, IntrNoReturn]>;
 
 // Since wasm does not use landingpad instructions, these instructions return
 // exception pointer and selector values until we lower them in WasmEHPrepare.
 def int_wasm_get_exception : Intrinsic<[llvm_ptr_ty], [], [IntrHasSideEffects]>;
 def int_wasm_get_ehselector : Intrinsic<[llvm_i32_ty], [],
                                         [IntrHasSideEffects]>;
+
+// 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_landingpad_index: Intrinsic<[], [llvm_i32_ty], [IntrNoMem]>;
+
+// Returns LSDA address of the current function.
+def int_wasm_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

lib/CodeGen/CMakeLists.txt

add_llvm_library(LLVMCodeGen
   TargetPassConfig.cpp
   TargetRegisterInfo.cpp
   TargetSchedule.cpp
   TargetSubtargetInfo.cpp
   TwoAddressInstructionPass.cpp
   UnreachableBlockElim.cpp
   ValueTypes.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) {
   initializeTailDuplicatePass(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/TargetPassConfig.cpp

void TargetPassConfig::addPassesToHandleExceptions() {
   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:
-    // TODO to prevent warning
+    // Wasm EH uses Windows EH instructions, but it does not need to demote PHIs
+    // on catchpads and cleanuppads because it does not outline them into
+    // funclets. Catchswitch blocks are not lowered in SelectionDAG, so we
+    // should remove PHIs there.
+    addPass(createWinEHPass(/*DemoteCatchSwitchPHIOnly=*/false));
+    addPass(createWasmEHPass());
     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 exception handling uses Windows exception IR for the middle level
+// representation. This pass does the following transformation for every
+// catchpad block:
+// (In C-style pseudocode)
+//
+// - Before:
+//   catchpad ...
+//   exn = wasm.get.exception();
+//   selector = wasm.get.selector();
+//   ...
+//
+// - After:
+//   catchpad ...
+//   exn = wasm.catch(0); // 0 is a tag for C++
+//   wasm.landingpad.index(index);
+//   // Only add below in case it's not a single catch (...)
+//   __wasm_lpad_context.lpad_index = index;
+//   __wasm_lpad_context.lsda = wasm.lsda();
+//   _Unwind_CallPersonality(exn);
+//   int selector = __wasm.landingpad_context.selector;
+//   ...
+//
+// Also, does the following for a cleanuppad block with a call to
+// __clang_call_terminate():
+// - Before:
+//   cleanuppad ...
+//   exn = wasm.get.exception();
+//   __clang_call_terminate(exn);
+//
+// - After:
+//   cleanuppad ...
+//   exn = wasm.catch(0); // 0 is a tag for C++
+//   __clang_call_terminate(exn);
+//
+//
+// * Background: 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 exceptions (e.g. JavaScript). We turn catchpads into catch (C++ tag)
+// and cleanuppads into catch_all, with one exception: cleanuppad with a call to
+// __clang_call_terminate should be both in catch (C++ tag) and catch_all.
+//
+//
+// * Background: Direct personality function call
+// In WebAssembly EH, the VM is responsible for unwinding the stack once an
+// exception is thrown. After the stack is unwound, the control flow is
+// transfered to WebAssembly 'catch' instruction, which returns a caught
+// exception object.
+//
+// Unwinding the 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 a catch instruction, we insert a call to 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
+// clause in a call frame and 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 catch intruction, after which the personality
+// function is called from the compiler-generated user code here.
+//
+// In libunwind, we have this struct that serves as a communincation channel
+// between the compiler-generated 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;
+// }
+//
+// We pass a landing pad index, and the address of LSDA for the current function
+// to the wrapper function _Unwind_CallPersonality in libunwind, and we retrieve
+// the selector after it returns.
+//
+//===----------------------------------------------------------------------===//
+
+#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/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.extract() intrinsic
+  Function *LPadIndexF = nullptr;       // wasm.landingpad.index() intrinsic
+  Function *LSDAF = nullptr;            // wasm.lsda() intrinsic
+  Function *GetExnF = nullptr;          // wasm.get.exception() intrinsic
+  Function *GetSelectorF = nullptr;     // wasm.get.ehselector() intrinsic
+  Function *CallPersonalityF = nullptr; // _Unwind_CallPersonality() wrapper
+  Function *ClangCallTermF = nullptr;   // __clang_call_terminate() function
+
+  void prepareEHPad(BasicBlock *BB, unsigned Index);
+  void prepareTerminateCleanupPad(BasicBlock *BB);
+
+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";
+  }
+};
+} // end anonymous namespace
+
+char WasmEHPrepare::ID = 0;
+INITIALIZE_PASS(WasmEHPrepare, DEBUG_TYPE, "Prepare WebAssembly exceptions",
+                false, false);
+
+FunctionPass *llvm::createWasmEHPass() { 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
+  );
+
+  // __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");
+
+  // wasm.catch() intinsic, which will be lowered to wasm 'catch' instruction.
+  CatchF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_catch);
+  // wasm.landingpad.index() intrinsic, which is to specify landingpad index
+  LPadIndexF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_landingpad_index);
+  // wasm.lsda() intrinsic. Returns the address of LSDA table for the current
+  // function.
+  LSDAF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_lsda);
+  // wasm.get.exception() and wasm.get.ehselector() intrinsics. Calls to these
+  // are generated in clang.
+  GetExnF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_get_exception);
+  GetSelectorF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_get_ehselector);
+
+  // _Unwind_CallPersonality() wrapper function, which calls the personality
+  CallPersonalityF = cast<Function>(M.getOrInsertFunction(
+      "_Unwind_CallPersonality", IRB.getInt32Ty(), IRB.getInt8PtrTy()));
+
+  // __clang_call_terminate() function, which is inserted by clang in case a
+  // cleanup throws
+  ClangCallTermF = M.getFunction("__clang_call_terminate");
+
+  return false;
+}
+
+bool WasmEHPrepare::runOnFunction(Function &F) {
+  SmallVector<BasicBlock *, 16> CatchPads;
+  SmallVector<BasicBlock *, 16> CleanupPads;
+  for (BasicBlock &BB : F) {
+    if (!BB.isEHPad())
+      continue;
+    if (isa<CatchPadInst>(BB.getFirstNonPHI()))
+      CatchPads.push_back(&BB);
+    else if (isa<CleanupPadInst>(BB.getFirstNonPHI()))
+      CleanupPads.push_back(&BB);
+  }
+
+  if (CatchPads.empty() && CleanupPads.empty())
+    return false;
+  assert(F.hasPersonalityFn() && "Personality function not found");
+
+  unsigned Index = 0;
+  for (auto *BB : CatchPads) {
+    auto *CPI = cast<CatchPadInst>(BB->getFirstNonPHI());
+    // In case of a single catch (...), we don't need to emit LSDA
+    if (CPI->getNumArgOperands() == 1 &&
+        cast<Constant>(CPI->getArgOperand(0))->isNullValue())
+      prepareEHPad(BB, -1);
+    else
+      prepareEHPad(BB, Index++);
+  }
+
+  if (!ClangCallTermF)
+    return !CatchPads.empty();
+
+  // Cleanuppads will turn into catch_all later, but cleanuppads with a call to
+  // __clang_call_terminate() is a special case. __clang_call_terminate() takes
+  // an exception object, so we have to duplicate call in both 'catch <C++ tag>'
+  // and 'catch_all' clauses. Here we only insert a call to catch; the
+  // duplication will be done later. In catch_all, the exception object will be
+  // set to null.
+  for (auto *BB : CleanupPads)
+    for (auto &I : *BB)
+      if (auto *CI = dyn_cast<CallInst>(&I))
+        if (CI->getCalledValue() == ClangCallTermF)
+          prepareEHPad(BB, -1);
+
+  return true;
+}
+
+void WasmEHPrepare::prepareEHPad(BasicBlock *BB, unsigned Index) {
+  assert(BB->isEHPad() && "BB is not an EHPad!");
+  IRBuilder<> IRB(BB->getContext());
+
+  IRB.SetInsertPoint(&*BB->getFirstInsertionPt());
+  // The argument to wasm.catch() is the tag for C++ exceptions, which we set to
+  // 0 for this module.
+  // Pseudocode: void *exn = wasm.catch(0);
+  Instruction *Exn = IRB.CreateCall(CatchF, IRB.getInt32(0), "exn");
+  // Replace the return value of wasm.get.exception() with the return value from
+  // wasm.catch().
+  Instruction *GetExnCI = nullptr, *GetSelectorCI = nullptr;
+  for (auto &I : *BB)
+    if (auto *CI = dyn_cast<CallInst>(&I)) {
+      if (CI->getCalledValue() == GetExnF)
+        GetExnCI = CI;
+      if (CI->getCalledValue() == GetSelectorF)
+        GetSelectorCI = CI;
+    }
+  assert(GetExnCI && "wasm.get.exception() call does not exist");
+  GetExnCI->replaceAllUsesWith(Exn);
+  GetExnCI->eraseFromParent();
+
+  // In case it is a catchpad with single catch (...) or a cleanuppad, we don't
+  // need to call personality function because we don't need a selector.
+  auto *FPI = cast<FuncletPadInst>(BB->getFirstNonPHI());
+  if (FPI->getNumArgOperands() == 0 ||
+      (FPI->getNumArgOperands() == 1 &&
+       cast<Constant>(FPI->getArgOperand(0))->isNullValue())) {
+    if (GetSelectorCI) {
+      assert(GetSelectorCI->use_empty() &&
+             "wasm.get.ehselector() still has uses!");
+      GetSelectorCI->eraseFromParent();
+    }
+    return;
+  }
+  IRB.SetInsertPoint(Exn->getNextNode());
+
+  // This is to create a map of <landingpad EH label, landingpad index> in
+  // SelectionDAGISel, which is to be used in EHStreamer to emit LSDA tables.
+  // Pseudocode: wasm.landingpad.index(Index);
+  IRB.CreateCall(LPadIndexF, IRB.getInt32(Index));
+
+  // Pseudocode: __wasm_lpad_context.lpad_index = index;
+  IRB.CreateStore(IRB.getInt32(Index), LPadIndexField);
+
+  // Store LSDA address only if this catchpad belongs to a top-level
+  // catchswitch. If there is another catchpad that dominates this pad, we don't
+  // need to store LSDA address again, because they are the same throughout the
+  // function and have been already stored before.
+  // TODO Can we not store LSDA address in user function but make libcxxabi
+  // compute it?
+  auto *CPI = cast<CatchPadInst>(FPI);
+  if (isa<ConstantTokenNone>(CPI->getCatchSwitch()->getParentPad()))
+    // Pseudocode: __wasm_lpad_context.lsda = wasm.lsda();
+    IRB.CreateStore(IRB.CreateCall(LSDAF), LSDAField);
+
+  // Pseudocode: _Unwind_CallPersonality(exn);
+  CallInst *PersCI =
+      IRB.CreateCall(CallPersonalityF, Exn, OperandBundleDef("funclet", CPI));
+  PersCI->setDoesNotThrow();
+
+  // Pseudocode: int selector = __wasm.landingpad_context.selector;
+  Instruction *Selector = IRB.CreateLoad(SelectorField, "selector");
+
+  // Replace the return value from wasm.get.ehselector() with the selector value
+  // loaded from __wasm_lpad_context.selector.
+  assert(GetSelectorCI && "wasm.get.ehselector() call does not exist");
+  GetSelectorCI->replaceAllUsesWith(Selector);
+  GetSelectorCI->eraseFromParent();
+}

lib/CodeGen/WinEHPrepare.cpp

cl::desc(
         "Clone multicolor basic blocks but do not demote cross funclet values"),
     cl::init(false));
 
 static cl::opt<bool> DisableCleanups(
     "disable-cleanups", cl::Hidden,
     cl::desc("Do not remove implausible terminators or other similar cleanups"),
     cl::init(false));
 
+static cl::opt<bool> DemoteCatchSwitchPHIOnlyOpt(
+    "demote-catchswitch-only", cl::Hidden,
+    cl::desc("Demote catchswitch BBs only (for wasm EH)"), cl::init(false));
+
 namespace {
   
 class WinEHPrepare : public FunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid.
-  WinEHPrepare() : FunctionPass(ID) {}
+  WinEHPrepare(bool DemoteCatchSwitchPHIOnly = false)
+      : FunctionPass(ID), DemoteCatchSwitchPHIOnly(DemoteCatchSwitchPHIOnly) {}
 
   bool runOnFunction(Function &Fn) override;
 
   bool doFinalization(Module &M) override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
   StringRef getPassName() const override {
     return "Windows exception handling preparation";
   }
 
 private:
   void insertPHIStores(PHINode *OriginalPHI, AllocaInst *SpillSlot);
   void
   insertPHIStore(BasicBlock *PredBlock, Value *PredVal, AllocaInst *SpillSlot,
                  SmallVectorImpl<std::pair<BasicBlock *, Value *>> &Worklist);
   AllocaInst *insertPHILoads(PHINode *PN, Function &F);
   void replaceUseWithLoad(Value *V, Use &U, AllocaInst *&SpillSlot,
                           DenseMap<BasicBlock *, Value *> &Loads, Function &F);
   bool prepareExplicitEH(Function &F);
   void colorFunclets(Function &F);
 
-  void demotePHIsOnFunclets(Function &F);
+  void demotePHIsOnFunclets(Function &F, bool DemoteCatchSwitchPHIOnly);
   void cloneCommonBlocks(Function &F);
   void removeImplausibleInstructions(Function &F);
   void cleanupPreparedFunclets(Function &F);
   void verifyPreparedFunclets(Function &F);
 
+  bool DemoteCatchSwitchPHIOnly;
+
   // All fields are reset by runOnFunction.
   EHPersonality Personality = EHPersonality::Unknown;
 
   const DataLayout *DL = nullptr;
   DenseMap<BasicBlock *, ColorVector> BlockColors;
   MapVector<BasicBlock *, std::vector<BasicBlock *>> FuncletBlocks;
 };
 
 } // end anonymous namespace
 
 char WinEHPrepare::ID = 0;
 INITIALIZE_PASS(WinEHPrepare, DEBUG_TYPE, "Prepare Windows exceptions",
                 false, false)
 
-FunctionPass *llvm::createWinEHPass() { return new WinEHPrepare(); }
+FunctionPass *llvm::createWinEHPass(bool DemoteCatchSwitchPHIOnly) {
+  return new WinEHPrepare(DemoteCatchSwitchPHIOnly);
+}
 
 bool WinEHPrepare::runOnFunction(Function &Fn) {
   if (!Fn.hasPersonalityFn())
     return false;
 
   // Classify the personality to see what kind of preparation we need.
   Personality = classifyEHPersonality(Fn.getPersonalityFn());
 
void WinEHPrepare::colorFunclets(Function &F) {
   // Invert the map from BB to colors to color to BBs.
   for (BasicBlock &BB : F) {
     ColorVector &Colors = BlockColors[&BB];
     for (BasicBlock *Color : Colors)
       FuncletBlocks[Color].push_back(&BB);
   }
 }
 
-void WinEHPrepare::demotePHIsOnFunclets(Function &F) {
+void WinEHPrepare::demotePHIsOnFunclets(Function &F,
+                                        bool DemoteCatchSwitchPHIOnly) {
   // Strip PHI nodes off of EH pads.
   SmallVector<PHINode *, 16> PHINodes;
   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE;) {
     BasicBlock *BB = &*FI++;
     if (!BB->isEHPad())
       continue;
+    if (DemoteCatchSwitchPHIOnly && !isa<CatchSwitchInst>(BB->getFirstNonPHI()))
+      continue;
+
     for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
       Instruction *I = &*BI++;
       auto *PN = dyn_cast<PHINode>(I);
       // Stop at the first non-PHI.
       if (!PN)
         break;
 
       AllocaInst *SpillSlot = insertPHILoads(PN, F);
bool WinEHPrepare::prepareExplicitEH(Function &F) {
   removeUnreachableBlocks(F);
 
   // Determine which blocks are reachable from which funclet entries.
   colorFunclets(F);
 
   cloneCommonBlocks(F);
 
   if (!DisableDemotion)
-    demotePHIsOnFunclets(F);
+    demotePHIsOnFunclets(F, DemoteCatchSwitchPHIOnly ||
+                         DemoteCatchSwitchPHIOnlyOpt);
 
   if (!DisableCleanups) {
     DEBUG(verifyFunction(F));
     removeImplausibleInstructions(F);
 
     DEBUG(verifyFunction(F));
     cleanupPreparedFunclets(F);
   }

test/CodeGen/WebAssembly/wasmehprepare.ll

+; RUN: opt < %s -winehprepare -demote-catchswitch-only -wasmehprepare -S | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+; CHECK: @__wasm_lpad_context = external global { i32, i8*, i32 }
+
+@_ZTIi = external constant i8*
+%struct.Cleanup = type { i8 }
+
+; A single 'catch (int)' clause.
+; A wasm.catch() call, wasm.lsda() call, and personality call to generate a
+; selector should all be genereated after the catchpad.
+define void @test0() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test0()
+entry:
+  invoke void @foo()
+          to label %try.cont unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %0 = catchswitch within none [label %catch.start] unwind to caller
+
+catch.start:                                      ; preds = %catch.dispatch
+  %1 = catchpad within %0 [i8* bitcast (i8** @_ZTIi to i8*)]
+  %2 = call i8* @llvm.wasm.get.exception()
+  %3 = call i32 @llvm.wasm.get.ehselector()
+  %4 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
+  %matches = icmp eq i32 %3, %4
+  br i1 %matches, label %catch, label %rethrow
+; CHECK: catch.start:
+; CHECK-NEXT:   %[[CATCHPAD:.*]] = catchpad
+; CHECK-NEXT:   %[[EXN:.*]] = call i8* @llvm.wasm.catch(i32 0)
+; CHECK-NEXT:   call void @llvm.wasm.landingpad.index(i32 0)
+; CHECK-NEXT:   store i32 0, i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 0)
+; CHECK-NEXT:   %[[LSDA:.*]] = call i8* @llvm.wasm.lsda()
+; CHECK-NEXT:   store i8* %[[LSDA]], i8** getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 1)
+; CHECK-NEXT:   call i32 @_Unwind_CallPersonality(i8* %[[EXN]]) {{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
+; CHECK-NEXT:   %[[SELECTOR:.*]] = load i32, i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 2)
+; CHECK:   icmp eq i32 %[[SELECTOR]]
+
+catch:                                            ; preds = %catch.start
+  %5 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
+  call void @__cxa_end_catch() [ "funclet"(token %1) ]
+  catchret from %1 to label %try.cont
+; CHECK: catch:
+; CHECK-NEXT:  call i8* @__cxa_begin_catch(i8* %[[EXN]])
+
+rethrow:                                          ; preds = %catch.start
+  call void @__cxa_rethrow() [ "funclet"(token %1) ]
+  unreachable
+
+try.cont:                                         ; preds = %entry, %catch
+  ret void
+}
+
+; Two try-catches, one of them is with a single 'catch (...)' clause.
+; For the catchpad with a single 'catch (...)', only a wasm.catch() call should
+; be generated after the catchpad; wasm.landingpad.index() and personality call
+; should NOT be generated. For the other catchpad, the argument of
+; wasm.landingpad.index() should be not 1 but 0.
+define void @test1() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test1()
+entry:
+  invoke void @foo()
+          to label %try.cont unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %0 = catchswitch within none [label %catch.start] unwind to caller
+
+catch.start:                                      ; preds = %catch.dispatch
+  %1 = catchpad within %0 [i8* null]
+  %2 = call i8* @llvm.wasm.get.exception()
+  %3 = call i32 @llvm.wasm.get.ehselector()
+  %4 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
+  call void @__cxa_end_catch() [ "funclet"(token %1) ]
+  catchret from %1 to label %try.cont
+; CHECK: catch.start:
+; CHECK-NEXT:   catchpad within %0 [i8* null]
+; CHECK-NEXT:   call i8* @llvm.wasm.catch(i32 0)
+; CHECK-NOT:   call void @llvm.wasm.landingpad.index
+; CHECK-NOT:   store {{.*}} @__wasm_lpad_context
+; CHECK-NOT:   call i8* @llvm.wasm.lsda()
+; CHECK-NOT:   call i32 @_Unwind_CallPersonality
+; CHECK-NOT:   load {{.*}} @__wasm_lpad_context
+
+try.cont:                                         ; preds = %entry, %catch.start
+  invoke void @foo()
+          to label %try.cont7 unwind label %catch.dispatch2
+
+catch.dispatch2:                                  ; preds = %try.cont
+  %5 = catchswitch within none [label %catch.start3] unwind to caller
+
+catch.start3:                                     ; preds = %catch.dispatch2
+  %6 = catchpad within %5 [i8* bitcast (i8** @_ZTIi to i8*)]
+  %7 = call i8* @llvm.wasm.get.exception()
+  %8 = call i32 @llvm.wasm.get.ehselector()
+  %9 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
+  %matches = icmp eq i32 %8, %9
+  br i1 %matches, label %catch4, label %rethrow
+; CHECK: catch.start3:
+; CHECK:   call void @llvm.wasm.landingpad.index(i32 0)
+
+catch4:                                           ; preds = %catch.start3
+  %10 = call i8* @__cxa_begin_catch(i8* %7) [ "funclet"(token %6) ]
+  call void @__cxa_end_catch() [ "funclet"(token %6) ]
+  catchret from %6 to label %try.cont7
+
+rethrow:                                          ; preds = %catch.start3
+  call void @__cxa_rethrow() [ "funclet"(token %6) ]
+  unreachable
+
+try.cont7:                                        ; preds = %try.cont, %catch4
+  ret void
+}
+
+; A nested try-catch within a catch. Within the nested catchpad, wasm.lsda()
+; call should NOT be generated.
+define void @test2() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test2()
+entry:
+  invoke void @foo()
+          to label %try.cont9 unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %0 = catchswitch within none [label %catch.start] unwind to caller
+
+catch.start:                                      ; preds = %catch.dispatch
+  %1 = catchpad within %0 [i8* bitcast (i8** @_ZTIi to i8*)]
+  %2 = call i8* @llvm.wasm.get.exception()
+  %3 = call i32 @llvm.wasm.get.ehselector()
+  %4 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
+  %matches = icmp eq i32 %3, %4
+  br i1 %matches, label %catch, label %rethrow
+; CHECK: catch.start:
+; CHECK:   call i8* @llvm.wasm.lsda()
+
+catch:                                            ; preds = %catch.start
+  %5 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
+  invoke void @foo() [ "funclet"(token %1) ]
+          to label %try.cont unwind label %catch.dispatch2
+
+catch.dispatch2:                                  ; preds = %catch
+  %6 = catchswitch within %1 [label %catch.start3] unwind label %ehcleanup
+
+catch.start3:                                     ; preds = %catch.dispatch2
+  %7 = catchpad within %6 [i8* bitcast (i8** @_ZTIi to i8*)]
+  %8 = call i8* @llvm.wasm.get.exception()
+  %9 = call i32 @llvm.wasm.get.ehselector()
+  %10 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
+  %matches4 = icmp eq i32 %9, %10
+  br i1 %matches4, label %catch6, label %rethrow5
+; CHECK: catch.start3:
+; CHECK-NOT:   call i8* @llvm.wasm.lsda()
+
+catch6:                                           ; preds = %catch.start3
+  %11 = call i8* @__cxa_begin_catch(i8* %8) [ "funclet"(token %7) ]
+  call void @__cxa_end_catch() [ "funclet"(token %7) ]
+  catchret from %7 to label %try.cont
+
+rethrow5:                                         ; preds = %catch.start3
+  invoke void @__cxa_rethrow() [ "funclet"(token %7) ]
+          to label %unreachable unwind label %ehcleanup
+
+try.cont:                                         ; preds = %catch, %catch6
+  call void @__cxa_end_catch() [ "funclet"(token %1) ]
+  catchret from %1 to label %try.cont9
+
+rethrow:                                          ; preds = %catch.start
+  call void @__cxa_rethrow() [ "funclet"(token %1) ]
+  unreachable
+
+try.cont9:                                        ; preds = %entry, %try.cont
+  ret void
+
+ehcleanup:                                        ; preds = %rethrow5, %catch.dispatch2
+  %12 = cleanuppad within %1 []
+  call void @__cxa_end_catch() [ "funclet"(token %12) ]
+  cleanupret from %12 unwind to caller
+; CHECK: ehcleanup:
+; CHECK-NEXT:   cleanuppad
+; CHECK-NOT:   call i8* @llvm.wasm.catch(i32 0)
+; CHECK-NOT:   call void @llvm.wasm.landingpad.index
+; CHECK-NOT:   store {{.*}} @__wasm_lpad_context
+; CHECK-NOT:   call i8* @llvm.wasm.lsda()
+; CHECK-NOT:   call i32 @_Unwind_CallPersonality
+; CHECK-NOT:   load {{.*}} @__wasm_lpad_context
+
+unreachable:                                      ; preds = %rethrow5
+  unreachable
+}
+
+; A cleanuppad with a call to __clang_call_terminate().
+; A call to wasm.catch() should be generated after the cleanuppad.
+define hidden void @test3() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test3
+entry:
+  invoke void @foo()
+          to label %try.cont unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %0 = catchswitch within none [label %catch.start] unwind to caller
+
+catch.start:                                      ; preds = %catch.dispatch
+  %1 = catchpad within %0 [i8* null]
+  %2 = call i8* @llvm.wasm.get.exception()
+  %3 = call i32 @llvm.wasm.get.ehselector()
+  %4 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
+  invoke void @foo() [ "funclet"(token %1) ]
+          to label %invoke.cont1 unwind label %ehcleanup
+
+invoke.cont1:                                     ; preds = %catch.start
+  call void @__cxa_end_catch() [ "funclet"(token %1) ]
+  catchret from %1 to label %try.cont
+
+try.cont:                                         ; preds = %entry, %invoke.cont1
+  ret void
+
+ehcleanup:                                        ; preds = %catch.start
+  %5 = cleanuppad within %1 []
+  invoke void @__cxa_end_catch() [ "funclet"(token %5) ]
+          to label %invoke.cont2 unwind label %terminate
+
+invoke.cont2:                                     ; preds = %ehcleanup
+  cleanupret from %5 unwind to caller
+
+terminate:                                        ; preds = %ehcleanup
+  %6 = cleanuppad within %5 []
+  %7 = call i8* @llvm.wasm.get.exception()
+  call void @__clang_call_terminate(i8* %7) [ "funclet"(token %6) ]
+  unreachable
+; CHECK: terminate:
+; CHECK-NEXT: cleanuppad
+; CHECK-NEXT:   %[[EXN:.*]] = call i8* @llvm.wasm.catch(i32 0)
+; CHECK-NEXT:   call void @__clang_call_terminate(i8* %[[EXN]])
+}
+
+; PHI demotion test. Only the phi before catchswitch should be demoted; the phi
+; before cleanuppad should NOT.
+define void @test5() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test5
+entry:
+  %c = alloca %struct.Cleanup, align 1
+  invoke void @foo()
+          to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  invoke void @foo()
+          to label %invoke.cont1 unwind label %ehcleanup
+
+invoke.cont1:                                     ; preds = %invoke.cont
+  %call = call %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* %c)
+  br label %try.cont
+
+ehcleanup:                                        ; preds = %invoke.cont, %entry
+  %num.0 = phi i32 [ 2, %invoke.cont ], [ 1, %entry ]
+  %0 = cleanuppad within none []
+  %call2 = call %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* %c) [ "funclet"(token %0) ]
+  cleanupret from %0 unwind label %catch.dispatch
+; CHECK: ehcleanup:
+; CHECK-NEXT:   = phi
+
+catch.dispatch:                                   ; preds = %ehcleanup
+  %1 = catchswitch within none [label %catch.start] unwind to caller
+
+catch.start:                                      ; preds = %catch.dispatch
+  %2 = catchpad within %1 [i8* null]
+  %3 = call i8* @llvm.wasm.get.exception()
+  %4 = call i32 @llvm.wasm.get.ehselector()
+  %5 = call i8* @__cxa_begin_catch(i8* %3) [ "funclet"(token %2) ]
+  call void @func(i32 %num.0) [ "funclet"(token %2) ]
+  call void @__cxa_end_catch() [ "funclet"(token %2) ]
+  catchret from %2 to label %try.cont
+
+try.cont:                                         ; preds = %catch.start, %invoke.cont1
+  invoke void @foo()
+          to label %invoke.cont3 unwind label %catch.dispatch5
+
+invoke.cont3:                                     ; preds = %try.cont
+  invoke void @foo()
+          to label %try.cont10 unwind label %catch.dispatch5
+
+catch.dispatch5:                                  ; preds = %invoke.cont3, %try.cont
+  %num.1 = phi i32 [ 2, %invoke.cont3 ], [ 1, %try.cont ]
+  %6 = catchswitch within none [label %catch.start6] unwind to caller
+; CHECK: catch.dispatch5:
+; CHECK-NOT:   = phi
+
+catch.start6:                                     ; preds = %catch.dispatch5
+  %7 = catchpad within %6 [i8* null]
+  %8 = call i8* @llvm.wasm.get.exception()
+  %9 = call i32 @llvm.wasm.get.ehselector()
+  %10 = call i8* @__cxa_begin_catch(i8* %8) [ "funclet"(token %7) ]
+  call void @func(i32 %num.1) [ "funclet"(token %7) ]
+  call void @__cxa_end_catch() [ "funclet"(token %7) ]
+  catchret from %7 to label %try.cont10
+
+try.cont10:                                       ; preds = %invoke.cont3, %catch.start6
+  ret void
+}
+
+declare void @foo()
+declare void @func(i32)
+declare %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* returned)
+declare i32 @__gxx_wasm_personality_v0(...)
+declare i8* @llvm.wasm.get.exception()
+declare i32 @llvm.wasm.get.ehselector()
+declare i32 @llvm.eh.typeid.for(i8*)
+declare i8* @__cxa_begin_catch(i8*)
+declare void @__cxa_end_catch()
+declare void @__cxa_rethrow()
+declare void @__clang_call_terminate(i8*)
+
+; CHECK-DAG: declare i8* @llvm.wasm.catch(i32)
+; CHECK-DAG: declare void @llvm.wasm.landingpad.index(i32)
+; CHECK-DAG: declare i8* @llvm.wasm.lsda()
+; CHECK-DAG: declare i32 @_Unwind_CallPersonality(i8*)
+

tools/opt/opt.cpp

int main(int argc, char **argv) {
   initializePreISelIntrinsicLoweringLegacyPassPass(Registry);
   initializeGlobalMergePass(Registry);
   initializeIndirectBrExpandPassPass(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");