[WebAssembly] Support instruction selection for catching exceptions

[aheejin]

Summary

This lowers exception catching-related instructions:

1. Lowers wasm.catch intrinsic to catch instruction
2. Removes catchpad and cleanuppad instructions; they are not necessary after isel phase (MachineBasicBlock::isEHFuncletEntry() or MachineBasicBlock::isEHPad() can be used instead.)
3. Lowers catchret and cleanupret instructions to pseudo catchret and cleanupret instructions in isel, which will be replaced with other instructions in WebAssemblyExceptionPrepare pass.
4. Adds WebAssemblyExceptionPrepare pass, which replaces catchret/cleanupret instructions with br and rethrow instructions appropriately.

Currently this does not handle lowering of intrinsics related to LSDA info generation (wasm.landingpad.index and wasm.lsda), because they cannot be tested without implementing EHStreamer's wasm-specific handlers. They are marked as TODO, which is needed to make isel pass. Also this does not generate try and end_try markers yet, which will be handled in later patches.

This patch is based on the first wasm EH proposal.

[aheejin]

If we use Windows EH instruction, this may have to change.

[aheejin]

Changed the patch to use previous EH proposal and WinEH instructions

[aheejin]

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

165 ↗

(On Diff #142556)

Now EH labels can be present and they are position instructions. I think we can safely ignore them here and don't need to crash.

lib/Target/WebAssembly/WebAssemblyRegisterInfo.h

48 ↗

(On Diff #142556)

This was needed to prevent assertions from these functions.

[aheejin]

• Add a missing condition

[aheejin]

Diff was messed up in the last commit; fixed.

[aheejin]

• Deleted the assertion added in D45711 (rL330217) because now we can have BBs without terminators.

[aheejin]

• tweak test case

[aheejin]

replaceFuncletReturnInstructions -> replaceFuncletReturns

[aheejin]

• clang-tidy

[aheejin]

• ExceptionPrepare -> ReplaceFuncletReturns

[dschuff]

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1319

Based on this comment I assume we are marking 'IsEHFuncletEntry' for a different purpose than MSVC (since we don't need a function prologue)? In that case I guess this comment should be updated. Likewise below. (what do we use it for?)

[aheejin]

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1319

Here the funclet means "BB structure starting from catchpad/cleanuppad and ending with catchret/cleanupret".

While I'm not very sure what that comment really means, I guess it's related to this code. I'm not very familiar with PrologEpilogInserter, but I guess that's the part wasm does not use, because we don't need to do caller-save and calle-save things.

OTOH, MachineBasicBlock::isEHFuncletEntry() method is used in several other places, and wasm needs at least a few of them, in which the method is used with the same meaning as isEHPad(). For example, here in getFuncletMembership, the method that computes funclet membership in order to problematic merges between funclets.

I think I should update the comment, but not very sure how. So apparently that method is used in PrologEpilogInserter but not only there and even wasm needs that at some point.

[aheejin]

rebase

[aheejin]

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1320

@majnemer MachineBasicBlock::isEHFuncletEntry() is apparently used in a lot of places including prolog/epilog generaton, and because we don't need prolog/epilog on funclet boundaries, I think should not set this flag for wasm, but here in getFuncletMembership checks isEHFuncletEntry and wasm needs this part. So I tried to change this to isEHPad() assuming that in WinEH isEHFuncletEntry and isEHPad are the same thing, but apparently I was wrong because now all the SEH testse are failing, which I don't know much about.

I guess we are facing the same problem as in D45559: we have two different functions for the use cases of 'funclet':

1. the BB structure starting from catchpad/cleanuppad and ending with catchret/cleanupret
2. the real outlined functions

In WinEH those two were the same thing but in wasm we don't need to outline them, which is the problem. Thoughts?

[aheejin]

• tweak test case

[aheejin]

• Early exit if a function does not have a personality function

[majnemer]

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

1323–1326

I think this would be cleaner as:

if (!IsWasmCXX)
  DAG.setRoot(DAG.getNode(ISD::CATCHPAD, getCurSDLoc(), MVT::Other, getControlRoot()));

6048

Maybe make fill in the TODO with a rough sketch of what it needs to do?

[aheejin]

rebase

[aheejin]

Address comments

[aheejin]

rebased onto D47005

[aheejin]

fix sorry

[aheejin]

I split MachineBasicBlock::isEHFuncletEntry and MachineBasicBlock::setIsEHFuncletEntry into two functions in D47005, as in the same vein with D45559, and rebased this CL onto it. PTAL.

[aheejin]

• clang-format

[aheejin]

• Make wasm.get.exception/ehselector intrinsic take a token argument

[aheejin]

Deleted ReplaceFuncletReturns pass and move the routine to ExceptionPrepare.

[dschuff]

Otherwise LGTM

lib/Target/WebAssembly/WebAssemblyRegisterInfo.h

48 ↗

(On Diff #142556)

There should be a comment about that here, since the mask is something that shouldn't apply to wasm.

[aheejin]

• Add a comment

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

SDValue SelectionDAGBuilder::getValueImpl(const Value *V) {
   llvm_unreachable("Can't get register for value!");
 }
 
 void SelectionDAGBuilder::visitCatchPad(const CatchPadInst &I) {
   auto Pers = classifyEHPersonality(FuncInfo.Fn->getPersonalityFn());
   bool IsMSVCCXX = Pers == EHPersonality::MSVC_CXX;
   bool IsCoreCLR = Pers == EHPersonality::CoreCLR;
   MachineBasicBlock *CatchPadMBB = FuncInfo.MBB;
   // In MSVC C++ and CoreCLR, catchblocks are funclets and need prologues.
   if (IsMSVCCXX || IsCoreCLR)
     CatchPadMBB->setIsEHFuncletEntry();
 
   DAG.setRoot(DAG.getNode(ISD::CATCHPAD, getCurSDLoc(), MVT::Other, getControlRoot()));
 }
 
 void SelectionDAGBuilder::visitCatchRet(const CatchReturnInst &I) {
   // Update machine-CFG edge.
   MachineBasicBlock *TargetMBB = FuncInfo.MBBMap[I.getSuccessor()];
   FuncInfo.MBB->addSuccessor(TargetMBB);
 
   auto Pers = classifyEHPersonality(FuncInfo.Fn->getPersonalityFn());
   bool IsSEH = isAsynchronousEHPersonality(Pers);
   if (IsSEH) {
     // If this is not a fall-through branch or optimizations are switched off,

   case Intrinsic::experimental_vector_reduce_smax:
   case Intrinsic::experimental_vector_reduce_smin:
   case Intrinsic::experimental_vector_reduce_umax:
   case Intrinsic::experimental_vector_reduce_umin:
   case Intrinsic::experimental_vector_reduce_fmax:
   case Intrinsic::experimental_vector_reduce_fmin:
     visitVectorReduce(I, Intrinsic);
     return nullptr;
+
+  case Intrinsic::wasm_eh_landingpad_index: {
+    // TODO
+    return nullptr;
+  }
+
   }
 }
 
 void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
     const ConstrainedFPIntrinsic &FPI) {
   SDLoc sdl = getCurSDLoc();
   unsigned Opcode;
   switch (FPI.getIntrinsicID()) {

lib/Target/WebAssembly/WebAssemblyCFGSort.cpp

 }
 
 static void MaybeUpdateTerminator(MachineBasicBlock *MBB) {
 #ifndef NDEBUG
   bool AnyBarrier = false;
 #endif
   bool AllAnalyzable = true;
   for (const MachineInstr &Term : MBB->terminators()) {
+    // We shouldn't update if_except terminator.
+    if (Term.getOpcode() == WebAssembly::IF_EXCEPT)
+      return;
 #ifndef NDEBUG
     AnyBarrier |= Term.isBarrier();
 #endif
     AllAnalyzable &= Term.isBranch() && !Term.isIndirectBranch();
   }
   assert((AnyBarrier || AllAnalyzable) &&
          "AnalyzeBranch needs to analyze any block with a fallthrough");
   if (AllAnalyzable)

lib/Target/WebAssembly/WebAssemblyISelLowering.h

private:
   SDValue LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerCopyToReg(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
 };
 
 namespace WebAssembly {
 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
                          const TargetLibraryInfo *libInfo);
 }  // end namespace WebAssembly
 
 }  // end namespace llvm
 
 #endif

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

WebAssemblyTargetLowering::WebAssemblyTargetLowering(
   setTruncStoreAction(MVT::f64, MVT::f32, Expand);
   for (auto T : MVT::integer_valuetypes())
     for (auto Ext : {ISD::EXTLOAD, ISD::ZEXTLOAD, ISD::SEXTLOAD})
       setLoadExtAction(Ext, T, MVT::i1, Promote);
 
   // Trap lowers to wasm unreachable
   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 
+  // Exception handling intrinsics
+  setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
+
   setMaxAtomicSizeInBitsSupported(64);
 }
 
 FastISel *WebAssemblyTargetLowering::createFastISel(
     FunctionLoweringInfo &FuncInfo, const TargetLibraryInfo *LibInfo) const {
   return WebAssembly::createFastISel(FuncInfo, LibInfo);
 }
 
BuildMI(*DoneMBB, DoneMBB->begin(), DL, TII.get(TargetOpcode::PHI), OutReg)
       .addReg(FalseReg)
       .addMBB(FalseMBB)
       .addReg(TrueReg)
       .addMBB(TrueMBB);
 
   return DoneMBB;
 }
 
+// Lower
+//   %val = wasm.catch.extract();
+// into
+//   %exn = catch
+//   if_except %exn 0
+//   then
+//     %val1 = get_except_stack
+//   else
+//     %val2 = _Unwind_GetExceptionProxy();
+//   end_if_except
+//   %val = phi %val1, %val2
+//
+// - if_except's immediate operand 0 is the tag for C++ exception.
+// - if_except queries if the except_ref object returned by catch instruction is
+//   a C++ exception (i.e., matches tag 0) or not. If the exception is a C++
+//   exception, if_except extracts the original value thrown from the except_ref
+//   object and pushes it onto the stack. Nothing is pushed if it is not a C++
+//   exception.
+// - In LLVM instructions, We cannot express the behavior that an instruction
+//   pushes a value onto the stack only under a certain condition.
+//   get_except_stack is a fake pseudo instruction assumed to get the extracted
+//   value from the stack when if_except is satisfied. This pseudo instruction
+//   will be deleted later.
+// - _Unwind_GetExceptionProxy() is a function in Wasm unwind library that
+//   returns a fake proxy exception object in case we catch a foreign exception.
+static MachineBasicBlock *LowerCatchExtract(MachineInstr &MI,
+                                            MachineBasicBlock *MBB,
+                                            const TargetInstrInfo &TII,
+                                            bool Int64) {
+  MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
+  const DebugLoc &DL = MI.getDebugLoc();
+  unsigned ExnValReg = MI.getOperand(0).getReg();
+
+  // Create BBs
+  MachineFunction *MF = MBB->getParent();
+  const BasicBlock *BB = MBB->getBasicBlock();
+  MachineBasicBlock *TrueMBB = MF->CreateMachineBasicBlock(BB);
+  MachineBasicBlock *FalseMBB = MF->CreateMachineBasicBlock(BB);
+  MachineBasicBlock *DoneMBB = MF->CreateMachineBasicBlock(BB);
+  MachineFunction::iterator It = ++MBB->getIterator();
+  MF->insert(It, TrueMBB);
+  MF->insert(It, FalseMBB);
+  MF->insert(It, DoneMBB);
+  // Transfer the remainder of BB and its successor edges to DoneMBB.
+  DoneMBB->splice(DoneMBB->begin(), MBB,
+                  std::next(MachineBasicBlock::iterator(MI)), MBB->end());
+  DoneMBB->transferSuccessorsAndUpdatePHIs(MBB);
+  MBB->addSuccessor(TrueMBB);
+  MBB->addSuccessor(FalseMBB);
+  TrueMBB->addSuccessor(DoneMBB);
+  FalseMBB->addSuccessor(DoneMBB);
+
+  // catch / if_except
+  unsigned ExnReg = MRI.createVirtualRegister(&WebAssembly::EXCEPT_REFRegClass);
+  BuildMI(*MBB, MI, DL, TII.get(WebAssembly::CATCH), ExnReg);
+  BuildMI(*MBB, MI, DL, TII.get(WebAssembly::IF_EXCEPT))
+      .addImm(0) // Tag for C++ exceptions
+      .addReg(ExnReg)
+      .addImm(int64_t(WebAssembly::ExprType::Void));
+  MI.eraseFromParent();
+
+  // if_except then part
+  BuildMI(TrueMBB, DL, TII.get(WebAssembly::THEN));
+  unsigned GetExceptStackOpcode = Int64 ? WebAssembly::GET_EXCEPT_STACK_I64
+                                        : WebAssembly::GET_EXCEPT_STACK_I32;
+
+  unsigned TrueReg = MRI.createVirtualRegister(MRI.getRegClass(ExnValReg));
+  BuildMI(TrueMBB, DL, TII.get(GetExceptStackOpcode), TrueReg);
+  BuildMI(TrueMBB, DL, TII.get(WebAssembly::BR)).addMBB(DoneMBB);
+
+  // if_except else part
+  BuildMI(FalseMBB, DL, TII.get(WebAssembly::ELSE));
+  unsigned CallOpcode = Int64 ? WebAssembly::CALL_I64 : WebAssembly::CALL_I32;
+  unsigned FalseReg = MRI.createVirtualRegister(MRI.getRegClass(ExnValReg));
+  const Module *M = MF->getFunction().getParent();
+  BuildMI(FalseMBB, DL, TII.get(CallOpcode), FalseReg)
+      .addGlobalAddress(M->getNamedValue("_Unwind_GetExceptionProxy"));
+  BuildMI(FalseMBB, DL, TII.get(WebAssembly::BR)).addMBB(DoneMBB);
+
+  // phi / end_if_except
+  BuildMI(*DoneMBB, DoneMBB->getFirstNonPHI(), DL, TII.get(WebAssembly::PHI),
+          ExnValReg)
+      .addReg(TrueReg)
+      .addMBB(TrueMBB)
+      .addReg(FalseReg)
+      .addMBB(FalseMBB);
+  BuildMI(*DoneMBB, DoneMBB->getFirstNonPHI(), DL,
+          TII.get(WebAssembly::END_IF_EXCEPT));
+
+  return DoneMBB;
+}
+
 MachineBasicBlock *
 WebAssemblyTargetLowering::EmitInstrWithCustomInserter(
     MachineInstr &MI,
     MachineBasicBlock *BB
 ) const {
   const TargetInstrInfo &TII = *Subtarget->getInstrInfo();
   DebugLoc DL = MI.getDebugLoc();
 
case WebAssembly::FP_TO_UINT_I32_F64:
     return LowerFPToInt(MI, DL, BB, TII, true, false, true,
                         WebAssembly::I32_TRUNC_U_F64);
   case WebAssembly::FP_TO_SINT_I64_F64:
     return LowerFPToInt(MI, DL, BB, TII, false, true, true,
                         WebAssembly::I64_TRUNC_S_F64);
   case WebAssembly::FP_TO_UINT_I64_F64:
     return LowerFPToInt(MI, DL, BB, TII, true, true, true,
                         WebAssembly::I64_TRUNC_U_F64);
-  llvm_unreachable("Unexpected instruction to emit with custom inserter");
+  case WebAssembly::CATCH_EXTRACT_I32:
+    return LowerCatchExtract(MI, BB, TII, false);
+  case WebAssembly::CATCH_EXTRACT_I64:
+    return LowerCatchExtract(MI, BB, TII, true);
   }
 }
 
 const char *WebAssemblyTargetLowering::getTargetNodeName(
     unsigned Opcode) const {
   switch (static_cast<WebAssemblyISD::NodeType>(Opcode)) {
     case WebAssemblyISD::FIRST_NUMBER:
       break;
case ISD::BRIND:
       return SDValue();
     case ISD::RETURNADDR: // Probably nothing meaningful can be returned here.
       fail(DL, DAG, "WebAssembly hasn't implemented __builtin_return_address");
       return SDValue();
     case ISD::FRAMEADDR:
       return LowerFRAMEADDR(Op, DAG);
     case ISD::CopyToReg:
       return LowerCopyToReg(Op, DAG);
+    case ISD::INTRINSIC_WO_CHAIN:
+      return LowerINTRINSIC_WO_CHAIN(Op, DAG);
   }
 }
 
 SDValue WebAssemblyTargetLowering::LowerCopyToReg(SDValue Op,
                                                   SelectionDAG &DAG) const {
   SDValue Src = Op.getOperand(2);
   if (isa<FrameIndexSDNode>(Src.getNode())) {
     // CopyToReg nodes don't support FrameIndex operands. Other targets select
SDValue WebAssemblyTargetLowering::LowerVASTART(SDValue Op,
   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
 
   SDValue ArgN = DAG.getCopyFromReg(DAG.getEntryNode(), DL,
                                     MFI->getVarargBufferVreg(), PtrVT);
   return DAG.getStore(Op.getOperand(0), DL, ArgN, Op.getOperand(1),
                       MachinePointerInfo(SV), 0);
 }
 
+SDValue
+WebAssemblyTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
+                                                   SelectionDAG &DAG) const {
+  unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
+  SDLoc DL(Op);
+  switch (IntNo) {
+  default:
+    return SDValue(); // Don't custom lower most intrinsics.
+
+  case Intrinsic::wasm_eh_lsda:
+    // TODO For now, just return 0 not to crash
+    return DAG.getConstant(0, DL, Op.getValueType());
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                          WebAssembly Optimization Hooks
 //===----------------------------------------------------------------------===//

lib/Target/WebAssembly/WebAssemblyInstrControl.td

def THROW_I32 : I<(outs), (ins i32imm:$tag, I32:$val),
                   0x08>;
 def THROW_I64 : I<(outs), (ins i32imm:$tag, I64:$val),
                   [(int_wasm_throw imm:$tag, I64:$val)], "throw   \t$tag, $val",
                   0x08>;
 def RETHROW : I<(outs), (ins i32imm:$rel_depth), [], "rethrow \t$rel_depth",
                 0x09>;
 } // isTerminator = 1, hasCtrlDep = 1, isBarrier = 1
 
+// Quering an exception tag: if_except / then / else / end_if_except
+// Retrieving an extracted exception value within if_except block:
+//   get_except_black (pseudo instruction)
+let hasCtrlDep = 1 in {
+let isBranch = 1, isTerminator = 1, hasSideEffects = 1 in
+def IF_EXCEPT : I<(outs),
+                  (ins i32imm:$tag, EXCEPT_REF:$obj, Signature:$sig), [],
+                  "if_except\t$tag, $obj", 0x0a>;
+def ELSE : I<(outs), (ins), [], "else", 0x05>;
+def END_IF_EXCEPT : I<(outs), (ins), [], "end_if_except", 0x0b>;
+
+let isCodeGenOnly = 1 in {
+def THEN : I<(outs), (ins), [], "then", 0>;
+def GET_EXCEPT_STACK_I32 : I<(outs I32:$dst), (ins), [],
+                             "get_except_stack $dst", 0>;
+def GET_EXCEPT_STACK_I64 : I<(outs I64:$dst), (ins), [],
+                             "get_except_stack $dst", 0>;
+}
+}
+
 // Region within which an exception is caught: try / end_try
 let Uses = [VALUE_STACK], Defs = [VALUE_STACK] in {
-def TRY     : I<(outs), (ins Signature:$sig), [], "try     \t$sig", 0x06>;
+def TRY : I<(outs), (ins Signature:$sig), [], "try     \t$sig", 0x06>;
 def END_TRY : I<(outs), (ins), [], "end_try", 0x0b>;
 } // Uses = [VALUE_STACK], Defs = [VALUE_STACK]
 
+// Catching an exception: catch / catch_extract
+// catch returns except_ref type object.
+// catch_extract is a pseudo instruction to which calls to wasm.catch.extract
+// intrinsic can be lowered into. This is a pseudo instruction that will be
+// further lowered into a sequence of catch / if_except / else / end_if_except.
+let hasCtrlDep = 1 in {
+def CATCH : I<(outs EXCEPT_REF:$dst), (ins), [], "catch   \t$dst", 0x07>;
+let isPseudo = 1, usesCustomInserter = 1 in {
+def CATCH_EXTRACT_I32 : I<(outs I32:$dst), (ins),
+                          [(set I32:$dst, (int_wasm_catch_extract))],
+                          "", 0>;
+def CATCH_EXTRACT_I64 : I<(outs I64:$dst), (ins),
+                          [(set I64:$dst, (int_wasm_catch_extract))],
+                          "", 0>;
+} // isPseudo = 1, usesCustomInserter = 1
+} // hasCtrlDep = 1
+
 } // Defs = [ARGUMENTS]
 
 // rethrow takes a relative depth as an argument, for which currently only 0 is
 // possible for C++. Once other languages need depths other than 0, depths will
 // be computed in CFGStackify.
 def : Pat<(int_wasm_rethrow), (RETHROW 0)>;

lib/Target/WebAssembly/WebAssemblyInstrInfo.cpp

case WebAssembly::BR:
       // If we're running after CFGStackify, we can't optimize further.
       if (!MI.getOperand(0).isMBB())
         return true;
       if (!HaveCond)
         TBB = MI.getOperand(0).getMBB();
       else
         FBB = MI.getOperand(0).getMBB();
       break;
+    case WebAssembly::IF_EXCEPT:
+      // if_except shouldn't be converted or optimized into another branch
+      // instructions.
+      return true;
     }
     if (MI.isBarrier())
       break;
   }
 
   return false;
 }
 

test/CodeGen/WebAssembly/exception.ll

-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -exception-model=wasm | FileCheck --match-full-lines %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare void @llvm.wasm.throw(i32, i8*)
 declare void @llvm.wasm.rethrow()
 
 ; CHECK-LABEL: throw:
 ; CHECK-NEXT: i32.const $push0=, 0
 ; CHECK-NEXT: throw 0, $pop0
 define void @throw() {
   call void @llvm.wasm.throw(i32 0, i8* null)
   ret void
 }
 
 ; CHECK-LABEL: rethrow:
 ; CHECK-NEXT: rethrow 0
 define void @rethrow() {
   call void @llvm.wasm.rethrow()
   ret void
 }
+
+; CHECK-LABEL: catch:
+; CHECK: call    maythrow@FUNCTION
+; CHECK: catch   $push[[NUM0:[0-9]+]]=
+; CHECK-NEXT: if_except 0, $pop[[NUM0]]
+; CHECK: then
+; CHECK-NEXT: get_except_stack $push[[NUM1:[0-9]+]]=
+; CHECK-NEXT: set_local [[LOCAL0:[0-9]+]], $pop[[NUM1]]
+; CHECK: else
+; CHECK-NEXT: i32.call $push[[NUM2:[0-9]+]]=, _Unwind_GetExceptionProxy@FUNCTION
+; CHECK-NEXT: set_local [[LOCAL0:[0-9]+]], $pop[[NUM2]]
+; CHECK: end_if_except
+; CHECK: get_local $push[[NUM3:[0-9]+]]=, [[LOCAL0]]
+; CHECK-NEXT: i32.call $push{{[0-9]+}}=, _Unwind_CallPersonality@FUNCTION, $pop[[NUM3]]
+define void @catch() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+entry:
+  invoke void @maythrow()
+          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
+  call void @__cxa_end_catch()
+  br label %try.cont
+
+try.cont:                                         ; preds = %entry, %lpad
+  ret void
+}
+
+declare i32 @__gxx_personality_v0(...)
+declare i8* @__cxa_begin_catch(i8*)
+declare void @__cxa_end_catch()
+declare void @maythrow()