[WebAssembly] Fix wasm.lsda() optimization in WasmEHPrepare

[aheejin]

Summary

When we insert a call to the personality function wrapper
(_Unwind_CallPersonality) for a catch pad, we store some necessary
info in __wasm_lpad_context struct and pass it. One of the info is the
LSDA address for the function. For this, we insert a call to
wasm.lsda(), which will be lowered down to the address of LSDA, and
store it in a field in __wasm_lpad_context.

There are exceptions to this personality call insertion: catchpads for
catch (...) and cleanuppads (for destructors) don't need personality
function calls, because we don't need to figure out whether the current
exception should be caught or not. (They always should.)

There was a little optimization to wasm.lsda() call insertion. Because
the LSDA address is the same throughout a function, we don't need to
insert a store of wasm.lsda() return value in every catchpad. For
example:

try {
  foo();
} catch (int) {
  // wasm.lsda() call and a store are inserted here, like, in
  // pseudocode,
  // %lsda = wasm.lsda();
  // store %lsda to a field in __wasm_lpad_context
  try {
    foo();
  } catch (int) {
    // We don't need to insert the wasm.lsda() and store again, because
    // to arrive here, we have already stored the LSDA address to
    // __wasm_lpad_context in the outer catch.
  }
}

So the previous algorithm checked if the current catch has a parent EH
pad, we didn't insert a call to wasm.lsda() and its store.

But this was incorrect, because what if the outer catch is catch (...)
or a cleanuppad?

try {
  foo();
} catch (...) {
  // wasm.lsda() call and a store are NOT inserted here
  try {
    foo();
  } catch (int) {
    // We need wasm.lsda() here!
  }
}

In this case we need to insert wasm.lsda() in the inner catchpad,
because the outer catchpad does not have one.

To minimize the number of inserted wasm.lsda() calls and stores, we
need a way to figure out whether we have encountered wasm.lsda() call
in any of EH pads that dominates the current EH pad. To figure that
out, we now visit EH pads in BFS order in the dominator tree so that we
visit parent BBs first before visiting its child BBs in the domtree.

We keep a set named ExecutedLSDA, which basically means "Do we have
wasm.lsda() either in the current EH pad or any of its parent EH
pads in the dominator tree?". This is to prevent scanning the domtree up
to the root in the worst case every time we examine an EH pad: each EH
pad only needs to examine its immediate parent EH pad.

• If any of its parent EH pads in the domtree has wasm.lsda(), this means we don't need wasm.lsda() in the current EH pad. We also insert the current EH pad in ExecutedLSDA set.
• If none of its parent EH pad has wasm.lsda()
  • If the current EH pad is a catch (...) or a cleanuppad, done.
  • If the current EH pad is neither a catch (...) nor a cleanuppad, add wasm.lsda() and the store in the current EH pad, and add the current EH pad to ExecutedLSDA set.

[aheejin]

• clang-format

[aheejin]

llvm/lib/CodeGen/WasmEHPrepare.cpp

307

This should've been NeedPersonality even before, which was a misnomer.

[aheejin]

• Comment fix

[aheejin]

• Add more comment

[dschuff]

I'm totally in favor of verbose commit descriptions :D
You can probably just remove the first paragraph.

llvm/lib/CodeGen/WasmEHPrepare.cpp

345

In principle, passes should be thread-safe if they have separate LLVMContext objects. Can we hang init off the pass object instead?

[aheejin]

• Change the static variable init to a class member variable IsEHFunctionsSetup (Not sure whether I should AreEHFunctionsSetup instead, but I think usually variable names start with Is..? Let me know if this sounds weird.)
• Move class member variable ExecutedLSDA to an auto variable in prepareEHPads. This variable is used only within that function.

[dschuff]

LGTM. I think IsFoo is probably fine even for plurals because it's a common convention as you say.
I guess if you wanted to be ultra-nitpicky-correct you could capitalize it as IsEHPadFunctionsSetUp (i.e. "set up" as 2 words instead of 1 since "setup" is a noun and "set up" is a verb phrase). But it's probably not worth bothering to change.

llvm/lib/CodeGen/WasmEHPrepare.cpp

128

Did you want to move this comment too?

[aheejin]

iIsEHPadFunctionsSetup -> IsEHPadFunctionsSetUp

llvm/lib/CodeGen/WasmEHPrepare.cpp

128

You mean the comment attached to ExecutedLSDA? No, now the long comment in prepareEHPads contains explanation of what that is for.

llvm/lib/CodeGen/WasmEHPrepare.cpp

 // }
 //
 // 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/BreadthFirstIterator.h"
 #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/CodeGen/WasmEHFuncInfo.h"
 #include "llvm/IR/Dominators.h"
class WasmEHPrepare : public FunctionPass {
   Function *ExtractExnF = nullptr;  // wasm.extract.exception() intrinsic
   Function *GetSelectorF = nullptr; // wasm.get.ehselector() intrinsic
   FunctionCallee CallPersonalityF =
       nullptr; // _Unwind_CallPersonality() wrapper
 
   bool prepareEHPads(Function &F);
   bool prepareThrows(Function &F);
 
-  void prepareEHPad(BasicBlock *BB, bool NeedLSDA, unsigned Index = 0);
+  bool IsEHPadFunctionsSetUp = false;
+  void setupEHPadFunctions(Function &F);
+  void prepareEHPad(BasicBlock *BB, bool NeedPersonality, bool NeedLSDA = false,
+                    unsigned Index = 0);
   void prepareTerminateCleanupPad(BasicBlock *BB);
 
 public:
   static char ID; // Pass identification, replacement for typeid
 
   WasmEHPrepare() : FunctionPass(ID) {}
-
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
   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",
+INITIALIZE_PASS_BEGIN(WasmEHPrepare, DEBUG_TYPE,
+                      "Prepare WebAssembly exceptions", false, false)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_PASS_END(WasmEHPrepare, DEBUG_TYPE, "Prepare WebAssembly exceptions",
                     false, false)
 
 FunctionPass *llvm::createWasmEHPass() { return new WasmEHPrepare(); }
 
+void WasmEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequired<DominatorTreeWrapperPass>();
+}
+
 bool WasmEHPrepare::doInitialization(Module &M) {
   IRBuilder<> IRB(M.getContext());
   LPadContextTy = StructType::get(IRB.getInt32Ty(),   // lpad_index
                                   IRB.getInt8PtrTy(), // lsda
                                   IRB.getInt32Ty()    // selector
   );
   return false;
 }
 
 // Erase the specified BBs if the BB does not have any remaining predecessors,
 // and also all its dead children.
 template <typename Container>
 static void eraseDeadBBsAndChildren(const Container &BBs) {
   SmallVector<BasicBlock *, 8> WL(BBs.begin(), BBs.end());
   while (!WL.empty()) {
     auto *BB = WL.pop_back_val();
     if (pred_begin(BB) != pred_end(BB))
       continue;
     WL.append(succ_begin(BB), succ_end(BB));
     DeleteDeadBlock(BB);
   }
 }
 
 bool WasmEHPrepare::runOnFunction(Function &F) {
+  IsEHPadFunctionsSetUp = false;
   bool Changed = false;
   Changed |= prepareThrows(F);
   Changed |= prepareEHPads(F);
   return Changed;
 }
 
 bool WasmEHPrepare::prepareThrows(Function &F) {
   Module &M = *F.getParent();
for (User *U : ThrowF->users()) {
     IRB.CreateUnreachable();
     eraseDeadBBsAndChildren(Succs);
   }
 
   return Changed;
 }
 
 bool WasmEHPrepare::prepareEHPads(Function &F) {
-  Module &M = *F.getParent();
-  IRBuilder<> IRB(F.getContext());
+  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  bool Changed = false;
 
-  SmallVector<BasicBlock *, 16> CatchPads;
-  SmallVector<BasicBlock *, 16> CleanupPads;
-  for (BasicBlock &BB : F) {
-    if (!BB.isEHPad())
+  // There are two things to decide: whether we need a personality function call
+  // and whether we need a `wasm.lsda()` call and its store.
+  //
+  // For the personality function call, catchpads with `catch (...)` and
+  // cleanuppads don't need it, because exceptions are always caught. Others all
+  // need it.
+  //
+  // For `wasm.lsda()` and its store, in order to minimize the number of them,
+  // we need a way to figure out whether we have encountered `wasm.lsda()` call
+  // in any of EH pads that dominates the current EH pad. To figure that out, we
+  // now visit EH pads in BFS order in the dominator tree so that we visit
+  // parent BBs first before visiting its child BBs in the domtree.
+  //
+  // We keep a set named `ExecutedLSDA`, which basically means "Do we have
+  // `wasm.lsda() either in the current EH pad or any of its parent EH pads in
+  // the dominator tree?". This is to prevent scanning the domtree up to the
+  // root every time we examine an EH pad, in the worst case: each EH pad only
+  // needs to check its immediate parent EH pad.
+  //
+  // - If any of its parent EH pads in the domtree has `wasm.lsda`, this means
+  //   we don't need `wasm.lsda()` in the current EH pad. We also insert the
+  //   current EH pad in `ExecutedLSDA` set.
+  // - If none of its parent EH pad has `wasm.lsda()`,
+  //   - If the current EH pad is a `catch (...)` or a cleanuppad, done.
+  //   - If the current EH pad is neither a `catch (...)` nor a cleanuppad,
+  //     add `wasm.lsda()` and the store in the current EH pad, and add the
+  //     current EH pad to `ExecutedLSDA` set.
+  //
+  // TODO Can we not store LSDA address in user function but make libcxxabi
+  // compute it?
+  DenseSet<Value *> ExecutedLSDA;
+  unsigned Index = 0;
+  for (auto DomNode : breadth_first(&DT)) {
+    auto *BB = DomNode->getBlock();
+    auto *Pad = BB->getFirstNonPHI();
+    if (!Pad || (!isa<CatchPadInst>(Pad) && !isa<CleanupPadInst>(Pad)))
       continue;
-    auto *Pad = BB.getFirstNonPHI();
-    if (isa<CatchPadInst>(Pad))
-      CatchPads.push_back(&BB);
-    else if (isa<CleanupPadInst>(Pad))
-      CleanupPads.push_back(&BB);
+    Changed = true;
+
+    Value *ParentPad = nullptr;
+    if (CatchPadInst *CPI = dyn_cast<CatchPadInst>(Pad)) {
+      ParentPad = CPI->getCatchSwitch()->getParentPad();
+      if (ExecutedLSDA.count(ParentPad)) {
+        ExecutedLSDA.insert(CPI);
+        // We insert its associated catchswitch too, because
+        // FuncletPadInst::getParentPad() returns a CatchSwitchInst if the child
+        // FuncletPadInst is a CleanupPadInst.
+        ExecutedLSDA.insert(CPI->getCatchSwitch());
+      }
+    } else { // CleanupPadInst
+      ParentPad = cast<CleanupPadInst>(Pad)->getParentPad();
+      if (ExecutedLSDA.count(ParentPad))
+        ExecutedLSDA.insert(Pad);
     }
 
-  if (CatchPads.empty() && CleanupPads.empty())
-    return false;
+    if (CatchPadInst *CPI = dyn_cast<CatchPadInst>(Pad)) {
+      if (CPI->getNumArgOperands() == 1 &&
+          cast<Constant>(CPI->getArgOperand(0))->isNullValue())
+        // In case of a single catch (...), we need neither personality call nor
+        // wasm.lsda() call
+        prepareEHPad(BB, false);
+      else {
+        if (ExecutedLSDA.count(CPI))
+          // catch (type), but one of parents already has wasm.lsda() call
+          prepareEHPad(BB, true, false, Index++);
+        else {
+          // catch (type), and none of parents has wasm.lsda() call. We have to
+          // add the call in this EH pad, and record this EH pad in
+          // ExecutedLSDA.
+          ExecutedLSDA.insert(CPI);
+          ExecutedLSDA.insert(CPI->getCatchSwitch());
+          prepareEHPad(BB, true, true, Index++);
+        }
+      }
+    } else if (isa<CleanupPadInst>(Pad)) {
+      // Cleanup pads need neither personality call nor wasm.lsda() call
+      prepareEHPad(BB, false);
+    }
+  }
+
+  return Changed;
+}
+
+void WasmEHPrepare::setupEHPadFunctions(Function &F) {
+  Module &M = *F.getParent();
+  IRBuilder<> IRB(F.getContext());
   assert(F.hasPersonalityFn() && "Personality function not found");
 
   // __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 =
void WasmEHPrepare::setupEHPadFunctions(Function &F) {
   ExtractExnF =
       Intrinsic::getDeclaration(&M, Intrinsic::wasm_extract_exception);
 
   // _Unwind_CallPersonality() wrapper function, which calls the personality
   CallPersonalityF = M.getOrInsertFunction(
       "_Unwind_CallPersonality", IRB.getInt32Ty(), IRB.getInt8PtrTy());
   if (Function *F = dyn_cast<Function>(CallPersonalityF.getCallee()))
     F->setDoesNotThrow();
-
-  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, false);
-    else
-      prepareEHPad(BB, true, Index++);
-  }
-
-  // Cleanup pads don't need LSDA.
-  for (auto *BB : CleanupPads)
-    prepareEHPad(BB, false);
-
-  return true;
 }
 
-// Prepare an EH pad for Wasm EH handling. If NeedLSDA is false, Index is
+// Prepare an EH pad for Wasm EH handling. If NeedPersonality is false, Index is
 // ignored.
-void WasmEHPrepare::prepareEHPad(BasicBlock *BB, bool NeedLSDA,
-                                 unsigned Index) {
+void WasmEHPrepare::prepareEHPad(BasicBlock *BB, bool NeedPersonality,
+                                 bool NeedLSDA, unsigned Index) {
+  if (!IsEHPadFunctionsSetUp) {
+    IsEHPadFunctionsSetUp = true;
+    setupEHPadFunctions(*BB->getParent());
+  }
   assert(BB->isEHPad() && "BB is not an EHPad!");
   IRBuilder<> IRB(BB->getContext());
   IRB.SetInsertPoint(&*BB->getFirstInsertionPt());
 
   auto *FPI = cast<FuncletPadInst>(BB->getFirstNonPHI());
   Instruction *GetExnCI = nullptr, *GetSelectorCI = nullptr;
   for (auto &U : FPI->uses()) {
     if (auto *CI = dyn_cast<CallInst>(U.getUser())) {
void WasmEHPrepare::prepareEHPad(BasicBlock *BB, bool NeedPersonality,
   }
 
   Instruction *ExtractExnCI = IRB.CreateCall(ExtractExnF, {}, "exn");
   GetExnCI->replaceAllUsesWith(ExtractExnCI);
   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.
-  if (!NeedLSDA) {
+  if (!NeedPersonality) {
     if (GetSelectorCI) {
       assert(GetSelectorCI->use_empty() &&
              "wasm.get.ehselector() still has uses!");
       GetSelectorCI->eraseFromParent();
     }
     return;
   }
   IRB.SetInsertPoint(ExtractExnCI->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, {FPI, 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()))
+  if (NeedLSDA)
     // Pseudocode: __wasm_lpad_context.lsda = wasm.lsda();
     IRB.CreateStore(IRB.CreateCall(LSDAF), LSDAField);
 
   // Pseudocode: _Unwind_CallPersonality(exn);
   CallInst *PersCI = IRB.CreateCall(CallPersonalityF, ExtractExnCI,
                                     OperandBundleDef("funclet", CPI));
   PersCI->setDoesNotThrow();
 

llvm/test/CodeGen/WebAssembly/wasmehprepare.ll

 rethrow:                                          ; preds = %catch.start3
   call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %6) ]
   unreachable
 
 try.cont7:                                        ; preds = %try.cont, %catch4
   ret void
 }
 
-; A nested try-catch within a catch.
+; A nested try-catch within a catch. The outer catch catches 'int'.
 ;
 ; void foo();
 ; void test2() {
 ;   try {
 ;     foo();
 ;   } catch (int) {
 ;     try {
 ;       foo();

 ; 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.
+; A nested try-catch within a catch. The outer catch is (...).
 ;
 ; void foo();
-; void test3() {
+; void test2() {
 ;   try {
 ;     foo();
 ;   } catch (...) {
-;     foo();
+;     try {
+;       foo();
+;     } catch (int) {
+;     }
 ;   }
 ; }
+; Within the innermost catchpad, wasm.lsda() call should be generated, because
+; the outer catch is 'catch (...)', which does not need wasm.lsda() call.
 define void @test3() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
-; CHECK-LABEL: @test3
+; CHECK-LABEL: @test3()
+entry:
+  invoke void @foo()
+          to label %try.cont8 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(token %1)
+  %3 = call i32 @llvm.wasm.get.ehselector(token %1)
+  %4 = call i8* @__cxa_begin_catch(i8* %2) [ "funclet"(token %1) ]
+  invoke void @foo() [ "funclet"(token %1) ]
+          to label %try.cont unwind label %catch.dispatch2
+; CHECK: catch.start:
+; CHECK-NOT:   call i8* @llvm.wasm.lsda()
+
+catch.dispatch2:                                  ; preds = %catch.start
+  %5 = catchswitch within %1 [label %catch.start3] unwind label %ehcleanup
+
+catch.start3:                                     ; preds = %catch.dispatch2
+  %6 = catchpad within %5 [i8* bitcast (i8** @_ZTIi to i8*)]
+  %7 = call i8* @llvm.wasm.get.exception(token %6)
+  %8 = call i32 @llvm.wasm.get.ehselector(token %6)
+  %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 i8* @llvm.wasm.lsda()
+
+catch4:                                           ; preds = %catch.start3
+  %10 = call i8* @__cxa_begin_catch(i8* %7) [ "funclet"(token %6) ]
+  %11 = bitcast i8* %10 to i32*
+  %12 = load i32, i32* %11, align 4
+  call void @__cxa_end_catch() [ "funclet"(token %6) ]
+  catchret from %6 to label %try.cont
+
+rethrow:                                          ; preds = %catch.start3
+  invoke void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %6) ]
+          to label %unreachable unwind label %ehcleanup
+
+try.cont:                                         ; preds = %catch.start, %catch4
+  call void @__cxa_end_catch() [ "funclet"(token %1) ]
+  catchret from %1 to label %try.cont8
+
+try.cont8:                                        ; preds = %entry, %try.cont
+  ret void
+
+ehcleanup:                                        ; preds = %rethrow, %catch.dispatch2
+  %13 = cleanuppad within %1 []
+  invoke void @__cxa_end_catch() [ "funclet"(token %13) ]
+          to label %invoke.cont6 unwind label %terminate
+
+invoke.cont6:                                     ; preds = %ehcleanup
+  cleanupret from %13 unwind to caller
+
+unreachable:                                      ; preds = %rethrow
+  unreachable
+
+terminate:                                        ; preds = %ehcleanup
+  %14 = cleanuppad within %13 []
+  %15 = call i8* @llvm.wasm.get.exception(token %14)
+  call void @__clang_call_terminate(i8* %15) [ "funclet"(token %14) ]
+  unreachable
+}
+
+; void foo();
+; void test4() {
+;   try {
+;     foo();
+;   } catch (int) {
+;     try {
+;       foo();
+;     } catch (...) {
+;       try {
+;         foo();
+;       } catch (int) {
+;       }
+;     }
+;   }
+; }
+; wasm.lsda() call should be generated only once in the outermost catchpad. The
+; innermost 'catch (int)' can reuse the wasm.lsda() generated in the outermost
+; catch.
+define void @test4() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test4()
+entry:
+  invoke void @foo()
+          to label %try.cont19 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(token %1)
+  %3 = call i32 @llvm.wasm.get.ehselector(token %1)
+  %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) ]
+  %6 = bitcast i8* %5 to i32*
+  %7 = load i32, i32* %6, align 4
+  invoke void @foo() [ "funclet"(token %1) ]
+          to label %try.cont16 unwind label %catch.dispatch2
+
+catch.dispatch2:                                  ; preds = %catch
+  %8 = catchswitch within %1 [label %catch.start3] unwind label %ehcleanup17
+
+catch.start3:                                     ; preds = %catch.dispatch2
+  %9 = catchpad within %8 [i8* null]
+  %10 = call i8* @llvm.wasm.get.exception(token %9)
+  %11 = call i32 @llvm.wasm.get.ehselector(token %9)
+  %12 = call i8* @__cxa_begin_catch(i8* %10) [ "funclet"(token %9) ]
+  invoke void @foo() [ "funclet"(token %9) ]
+          to label %try.cont unwind label %catch.dispatch7
+; CHECK: catch.start3:
+; CHECK-NOT:   call i8* @llvm.wasm.lsda()
+
+catch.dispatch7:                                  ; preds = %catch.start3
+  %13 = catchswitch within %9 [label %catch.start8] unwind label %ehcleanup
+
+catch.start8:                                     ; preds = %catch.dispatch7
+  %14 = catchpad within %13 [i8* bitcast (i8** @_ZTIi to i8*)]
+  %15 = call i8* @llvm.wasm.get.exception(token %14)
+  %16 = call i32 @llvm.wasm.get.ehselector(token %14)
+  %17 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
+  %matches9 = icmp eq i32 %16, %17
+  br i1 %matches9, label %catch11, label %rethrow10
+; CHECK: catch.start8:
+; CHECK-NOT:   call i8* @llvm.wasm.lsda()
+
+catch11:                                          ; preds = %catch.start8
+  %18 = call i8* @__cxa_begin_catch(i8* %15) [ "funclet"(token %14) ]
+  %19 = bitcast i8* %18 to i32*
+  %20 = load i32, i32* %19, align 4
+  call void @__cxa_end_catch() [ "funclet"(token %14) ]
+  catchret from %14 to label %try.cont
+
+rethrow10:                                        ; preds = %catch.start8
+  invoke void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %14) ]
+          to label %unreachable unwind label %ehcleanup
+
+try.cont:                                         ; preds = %catch.start3, %catch11
+  invoke void @__cxa_end_catch() [ "funclet"(token %9) ]
+          to label %invoke.cont13 unwind label %ehcleanup17
+
+invoke.cont13:                                    ; preds = %try.cont
+  catchret from %9 to label %try.cont16
+
+try.cont16:                                       ; preds = %catch, %invoke.cont13
+  call void @__cxa_end_catch() [ "funclet"(token %1) ]
+  catchret from %1 to label %try.cont19
+
+rethrow:                                          ; preds = %catch.start
+  call void @llvm.wasm.rethrow.in.catch() [ "funclet"(token %1) ]
+  unreachable
+
+try.cont19:                                       ; preds = %entry, %try.cont16
+  ret void
+
+ehcleanup:                                        ; preds = %rethrow10, %catch.dispatch7
+  %21 = cleanuppad within %9 []
+  invoke void @__cxa_end_catch() [ "funclet"(token %21) ]
+          to label %invoke.cont14 unwind label %terminate
+
+invoke.cont14:                                    ; preds = %ehcleanup
+  cleanupret from %21 unwind label %ehcleanup17
+
+ehcleanup17:                                      ; preds = %invoke.cont14, %try.cont, %catch.dispatch2
+  %22 = cleanuppad within %1 []
+  call void @__cxa_end_catch() [ "funclet"(token %22) ]
+  cleanupret from %22 unwind to caller
+
+unreachable:                                      ; preds = %rethrow10
+  unreachable
+
+terminate:                                        ; preds = %ehcleanup
+  %23 = cleanuppad within %21 []
+  %24 = call i8* @llvm.wasm.get.exception(token %23)
+  call void @__clang_call_terminate(i8* %24) [ "funclet"(token %23) ]
+  unreachable
+}
+
+; A cleanuppad with a call to __clang_call_terminate().
+;
+; void foo();
+; void test5() {
+;   try {
+;     foo();
+;   } catch (...) {
+;     foo();
+;   }
+; }
+define void @test5() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test5
 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

 ; before cleanuppad should NOT.
 ;
 ; void foo();
 ; int bar(int) noexcept;
 ; struct Temp {
 ;   ~Temp() {}
 ; };
 ;
-; void test4() {
+; void test6() {
 ;   int num;
 ;   try {
 ;     Temp t;
 ;     num = 1;
 ;     foo();
 ;     num = 2;
 ;     foo();
 ;   } catch (...) {
 ;     bar(num);
 ;   }
 ;   try {
 ;     foo();
 ;     num = 1;
 ;     foo();
 ;     num = 2;
 ;   } catch (...) {
 ;     bar(num);
 ;   }
 ; }
-define void @test4() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
-; CHECK-LABEL: @test4
+define void @test6() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @test6
 entry:
   %t = alloca %struct.Temp, 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

 
 try.cont10:                                       ; preds = %invoke.cont3, %catch.start6
   ret void
 }
 
 ; Tests if instructions after a call to @llvm.wasm.throw are deleted and the
 ; BB's dead children are deleted.
 
-; CHECK-LABEL: @test5
-define i32 @test5(i1 %b, i8* %p) {
+; CHECK-LABEL: @test7
+define i32 @test7(i1 %b, i8* %p) {
 entry:
   br i1 %b, label %bb.true, label %bb.false
 
 ; CHECK:      bb.true:
 ; CHECK-NEXT:   call void @llvm.wasm.throw(i32 0, i8* %p)
 ; CHECK-NEXT:   unreachable
 bb.true:                                          ; preds = %entry
   call void @llvm.wasm.throw(i32 0, i8* %p)