WIP: Unwindabort: Implement CodeGen for DWARF-style exception handling.

[jyknight]

Summary

This change causes 'call unwindabort' to emit EH_LABELs and add them
to the list of EH regions, in both SelectionDAG and GlobalISel.

It also adjusts the DWARF "resume" lowering to lower "resume
unwindabort" to "call unwindabort" appropriately.

The actual LSDA callsite table emission did not require any changes:
it already worked as desired. Test-cases were added, however.

This does not yet implement support for the other varieties of
exception-handling supported by LLVM:

• Windows funclets
• WebAssembly
• setjmp/longjmp

TODO: currently basic-block-sections are broken, as they have a
pre-existing flaw: they emit invalid unwind tables, where the callsite
table size is larger than it should be. The assumption in the initial
commit was that this was a harmless lie: that the unwinder would never
notice the garbage after the callsites, because the prior entries
would cover the whole function. That was not _necessarily_ the case
before, but is definitely not the case now.

Depends on D141916

[jroelofs]

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

2530

no else after return?

[jyknight]

Rebase patch.

[jyknight]

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

2530

The else is for CI.isInlineAsm(), so correct as is. Might be easier to read formatted like this?

if (CI.isInlineAsm()) {
  if (!translateInlineAsm(CI, MIRBuilder))
    return false;
} else {
  if (!translateCallBase(CI, MIRBuilder))
    return false;
}

[jroelofs]

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

2530

I realize now that what I was suggesting wasn't correct. No preference, now that I understand my mistake.

llvm/include/llvm/CodeGen/WinEHFuncInfo.h

 #include <cstdint>
 #include <limits>
 #include <utility>
 
 namespace llvm {
 
 class AllocaInst;
 class BasicBlock;
+class CallBase;
 class FuncletPadInst;
 class Function;
 class GlobalVariable;
 class Instruction;
 class InvokeInst;
 class MachineBasicBlock;
 class MCSymbol;
 
struct WinEHFuncInfo {
   SmallVector<WinEHTryBlockMapEntry, 4> TryBlockMap;
   SmallVector<SEHUnwindMapEntry, 4> SEHUnwindMap;
   SmallVector<ClrEHUnwindMapEntry, 4> ClrEHUnwindMap;
   int UnwindHelpFrameIdx = std::numeric_limits<int>::max();
   int PSPSymFrameIdx = std::numeric_limits<int>::max();
 
   int getLastStateNumber() const { return CxxUnwindMap.size() - 1; }
 
-  void addIPToStateRange(const InvokeInst *II, MCSymbol *InvokeBegin,
+  void addIPToStateRange(const CallBase *CB, MCSymbol *InvokeBegin,
                          MCSymbol *InvokeEnd);
 
   void addIPToStateRange(int State, MCSymbol *InvokeBegin, MCSymbol *InvokeEnd);
 
   int EHRegNodeFrameIndex = std::numeric_limits<int>::max();
   int EHRegNodeEndOffset = std::numeric_limits<int>::max();
   int EHGuardFrameIndex = std::numeric_limits<int>::max();
   int SEHSetFrameOffset = std::numeric_limits<int>::max();

llvm/lib/CodeGen/Analysis.cpp

 /// between it and the return.
 ///
 /// This function only tests target-independent requirements.
 bool llvm::isInTailCallPosition(const CallBase &Call, const TargetMachine &TM) {
   const BasicBlock *ExitBB = Call.getParent();
   const Instruction *Term = ExitBB->getTerminator();
   const ReturnInst *Ret = dyn_cast<ReturnInst>(Term);
 
+  // A call marked unwindabort cannot be tail called, because the unwinder must
+  // examine the call frame.
+  if (Call.isUnwindAbort())
+    return false;
+
   // The block must end in a return statement or unreachable.
   //
   // FIXME: Decline tailcall if it's not guaranteed and if the block ends in
   // an unreachable, for now. The way tailcall optimization is currently
   // implemented means it will add an epilogue followed by a jump. That is
   // not profitable. Also, if the callee is a special function (e.g.
   // longjmp on x86), it can end up causing miscompilation that has not
   // been fully understood.

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

for (unsigned j = 0, E = LandingPad->BeginLabels.size(); j != E; ++j) {
       PadMap[BeginLabel] = P;
     }
   }
 }
 
 /// Compute the call-site table.  The entry for an invoke has a try-range
 /// containing the call, a non-zero landing pad, and an appropriate action.  The
 /// entry for an ordinary call has a try-range containing the call and zero for
-/// the landing pad and the action.  Calls marked 'nounwind' have no entry and
-/// must not be contained in the try-range of any entry - they form gaps in the
-/// table.  Entries must be ordered by try-range address.
+/// the landing pad and the action.  Calls marked 'unwindabort' have no entry
+/// and must not be contained in the try-range of any entry - they form gaps in
+/// the table.  Calls marked 'nounwind' may be covered by anything -- either a
+/// neighboring entry or a gap. Entries must be ordered by try-range address.
 ///
 /// Call-sites are split into one or more call-site ranges associated with
 /// different sections of the function.
 ///
 ///   - Without -basic-block-sections, all call-sites are grouped into one
 ///     call-site-range corresponding to the function section.
 ///
 ///   - With -basic-block-sections, one call-site range is created for each

llvm/lib/CodeGen/DwarfEHPrepare.cpp

class DwarfEHPrepare {
 
   /// Return the exception object from the value passed into
   /// the 'resume' instruction (typically an aggregate). Clean up any dead
   /// instructions, including the 'resume' instruction.
   Value *GetExceptionObject(ResumeInst *RI);
 
   /// Replace resumes that are not reachable from a cleanup landing pad with
   /// unreachable and then simplify those blocks.
-  size_t
-  pruneUnreachableResumes(SmallVectorImpl<ResumeInst *> &Resumes,
+  void pruneUnreachableResumes(SmallVectorImpl<ResumeInst *> &Resumes,
                                SmallVectorImpl<LandingPadInst *> &CleanupLPads);
 
   /// Convert the ResumeInsts that are still present
   /// into calls to the appropriate _Unwind_Resume function.
   bool InsertUnwindResumeCalls();
 
 public:
   DwarfEHPrepare(CodeGenOpt::Level OptLevel_, Function &F_,
                  const TargetLowering &TLI_, DomTreeUpdater *DTU_,
if (ExcIVI->use_empty())
       ExcIVI->eraseFromParent();
     if (SelLoad && SelLoad->use_empty())
       SelLoad->eraseFromParent();
   }
 
   return ExnObj;
 }
 
-size_t DwarfEHPrepare::pruneUnreachableResumes(
+void DwarfEHPrepare::pruneUnreachableResumes(
     SmallVectorImpl<ResumeInst *> &Resumes,
     SmallVectorImpl<LandingPadInst *> &CleanupLPads) {
   assert(DTU && "Should have DomTreeUpdater here.");
 
   BitVector ResumeReachable(Resumes.size());
   size_t ResumeIndex = 0;
   for (auto *RI : Resumes) {
     for (auto *LP : CleanupLPads) {
       if (isPotentiallyReachable(LP, RI, nullptr, &DTU->getDomTree())) {
         ResumeReachable.set(ResumeIndex);
         break;
       }
     }
     ++ResumeIndex;
   }
 
   // If everything is reachable, there is no change.
   if (ResumeReachable.all())
-    return Resumes.size();
+    return;
 
   LLVMContext &Ctx = F.getContext();
 
   // Otherwise, insert unreachable instructions and call simplifycfg.
   size_t ResumesLeft = 0;
   for (size_t I = 0, E = Resumes.size(); I < E; ++I) {
     ResumeInst *RI = Resumes[I];
     if (ResumeReachable[I]) {
       Resumes[ResumesLeft++] = RI;
     } else {
       BasicBlock *BB = RI->getParent();
       new UnreachableInst(Ctx, RI);
       RI->eraseFromParent();
       simplifyCFG(BB, *TTI, DTU);
     }
   }
   Resumes.resize(ResumesLeft);
-  return ResumesLeft;
 }
 
 bool DwarfEHPrepare::InsertUnwindResumeCalls() {
-  SmallVector<ResumeInst *, 16> Resumes;
+  SmallVector<ResumeInst *, 16> AbortResumes, NormalResumes;
   SmallVector<LandingPadInst *, 16> CleanupLPads;
   if (F.doesNotThrow())
     NumNoUnwind++;
   else
     NumUnwind++;
   for (BasicBlock &BB : F) {
-    if (auto *RI = dyn_cast<ResumeInst>(BB.getTerminator()))
-      Resumes.push_back(RI);
+    if (auto *RI = dyn_cast<ResumeInst>(BB.getTerminator())) {
+      if (RI->isUnwindAbort())
+        AbortResumes.push_back(RI);
+      else
+        NormalResumes.push_back(RI);
+    }
     if (auto *LP = BB.getLandingPadInst())
       if (LP->isCleanup())
         CleanupLPads.push_back(LP);
   }
 
   NumCleanupLandingPadsRemaining += CleanupLPads.size();
 
-  if (Resumes.empty())
+  if (NormalResumes.empty() && AbortResumes.empty())
     return false;
 
   // Check the personality, don't do anything if it's scope-based.
   EHPersonality Pers = classifyEHPersonality(F.getPersonalityFn());
   if (isScopedEHPersonality(Pers))
     return false;
 
   LLVMContext &Ctx = F.getContext();
 
-  size_t ResumesLeft = Resumes.size();
   if (OptLevel != CodeGenOpt::None) {
-    ResumesLeft = pruneUnreachableResumes(Resumes, CleanupLPads);
+    pruneUnreachableResumes(NormalResumes, CleanupLPads);
+    pruneUnreachableResumes(AbortResumes, CleanupLPads);
 #if LLVM_ENABLE_STATS
     unsigned NumRemainingLPs = 0;
     for (BasicBlock &BB : F) {
       if (auto *LP = BB.getLandingPadInst())
         if (LP->isCleanup())
           NumRemainingLPs++;
     }
     NumCleanupLandingPadsUnreachable += CleanupLPads.size() - NumRemainingLPs;
     NumCleanupLandingPadsRemaining -= CleanupLPads.size() - NumRemainingLPs;
 #endif
   }
 
-  if (ResumesLeft == 0)
+  if (NormalResumes.empty() && AbortResumes.empty())
     return true; // We pruned them all.
 
   // RewindFunction - _Unwind_Resume or the target equivalent.
   FunctionCallee RewindFunction;
   CallingConv::ID RewindFunctionCallingConv;
   FunctionType *FTy;
   const char *RewindName;
   bool DoesRewindFunctionNeedExceptionObject;
if ((Pers == EHPersonality::GNU_CXX || Pers == EHPersonality::GNU_CXX_SjLj) &&
     RewindName = TLI.getLibcallName(RTLIB::UNWIND_RESUME);
     FTy =
         FunctionType::get(Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false);
     RewindFunctionCallingConv = TLI.getLibcallCallingConv(RTLIB::UNWIND_RESUME);
     DoesRewindFunctionNeedExceptionObject = true;
   }
   RewindFunction = F.getParent()->getOrInsertFunction(RewindName, FTy);
 
-  // Create the basic block where the _Unwind_Resume call will live.
-  if (ResumesLeft == 1) {
-    // Instead of creating a new BB and PHI node, just append the call to
-    // _Unwind_Resume to the end of the single resume block.
-    ResumeInst *RI = Resumes.front();
-    BasicBlock *UnwindBB = RI->getParent();
-    Value *ExnObj = GetExceptionObject(RI);
+  // Helper to create the call instruction
+  auto CreateRewindCall = [&](BasicBlock *UnwindBB, Value *ExnObj,
+                              bool UnwindAbort) {
     llvm::SmallVector<Value *, 1> RewindFunctionArgs;
     if (DoesRewindFunctionNeedExceptionObject)
       RewindFunctionArgs.push_back(ExnObj);
 
-    // Call the rewind function.
+    // Call the function.
     CallInst *CI =
         CallInst::Create(RewindFunction, RewindFunctionArgs, "", UnwindBB);
     // The verifier requires that all calls of debug-info-bearing functions
     // from debug-info-bearing functions have a debug location (for inlining
     // purposes). Assign a dummy location to satisfy the constraint.
     Function *RewindFn = dyn_cast<Function>(RewindFunction.getCallee());
     if (RewindFn && RewindFn->getSubprogram())
       if (DISubprogram *SP = F.getSubprogram())
         CI->setDebugLoc(DILocation::get(SP->getContext(), 0, 0, SP));
+
     CI->setCallingConv(RewindFunctionCallingConv);
+    CI->setUnwindAbort(UnwindAbort);
 
     // We never expect _Unwind_Resume to return.
     CI->setDoesNotReturn();
     new UnreachableInst(Ctx, UnwindBB);
-    return true;
+  };
+
+  // We may need to insert two separate blocks: one for the lowered 'resume' and
+  // one for the lowered 'resume unwindabort'.
+  for (auto &Resumes : {NormalResumes, AbortResumes}) {
+    if (Resumes.empty())
+      continue;
+    // Create the basic block where the _Unwind_Resume call will live.
+    if (Resumes.size() == 1) {
+      // Instead of creating a new BB and PHI node, just append the call to
+      // _Unwind_Resume to the end of the single resume block.
+      ResumeInst *RI = Resumes.front();
+      BasicBlock *UnwindBB = RI->getParent();
+      Value *ExnObj = GetExceptionObject(RI);
+      CreateRewindCall(UnwindBB, ExnObj, RI->isUnwindAbort());
+      continue;
     }
 
     std::vector<DominatorTree::UpdateType> Updates;
     Updates.reserve(Resumes.size());
 
-  llvm::SmallVector<Value *, 1> RewindFunctionArgs;
-
     BasicBlock *UnwindBB = BasicBlock::Create(Ctx, "unwind_resume", &F);
-  PHINode *PN = PHINode::Create(Type::getInt8PtrTy(Ctx), ResumesLeft, "exn.obj",
-                                UnwindBB);
+    PHINode *PN = PHINode::Create(Type::getInt8PtrTy(Ctx), Resumes.size(),
+                                  "exn.obj", UnwindBB);
 
-  // Extract the exception object from the ResumeInst and add it to the PHI node
-  // that feeds the _Unwind_Resume call.
+    // Extract the exception object from the ResumeInst and add it to the PHI
+    // node that feeds the _Unwind_Resume call.
     for (ResumeInst *RI : Resumes) {
       BasicBlock *Parent = RI->getParent();
       BranchInst::Create(UnwindBB, Parent);
       Updates.push_back({DominatorTree::Insert, Parent, UnwindBB});
 
       Value *ExnObj = GetExceptionObject(RI);
       PN->addIncoming(ExnObj, Parent);
 
       ++NumResumesLowered;
     }
 
-  if (DoesRewindFunctionNeedExceptionObject)
-    RewindFunctionArgs.push_back(PN);
-
-  // Call the function.
-  CallInst *CI =
-      CallInst::Create(RewindFunction, RewindFunctionArgs, "", UnwindBB);
-  CI->setCallingConv(RewindFunctionCallingConv);
-
-  // We never expect _Unwind_Resume to return.
-  CI->setDoesNotReturn();
-  new UnreachableInst(Ctx, UnwindBB);
-
+    CreateRewindCall(UnwindBB, PN, Resumes.front()->isUnwindAbort());
     if (DTU)
       DTU->applyUpdates(Updates);
+  }
 
   return true;
 }
 
 bool DwarfEHPrepare::run() {
   bool Changed = InsertUnwindResumeCalls();
 
   return Changed;

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

bool IRTranslator::translateCall(const User &U, MachineIRBuilder &MIRBuilder) {
   // FIXME: support control flow guard targets.
   if (CI.countOperandBundlesOfType(LLVMContext::OB_cfguardtarget))
     return false;
 
   // FIXME: support statepoints and related.
   if (isa<GCStatepointInst, GCRelocateInst, GCResultInst>(U))
     return false;
 
-  if (CI.isInlineAsm())
-    return translateInlineAsm(CI, MIRBuilder);
-
   diagnoseDontCall(CI);
 
   Intrinsic::ID ID = Intrinsic::not_intrinsic;
   if (F && F->isIntrinsic()) {
     ID = F->getIntrinsicID();
     if (TII && ID == Intrinsic::not_intrinsic)
       ID = static_cast<Intrinsic::ID>(TII->getIntrinsicID(F));
   }
 
-  if (!F || !F->isIntrinsic() || ID == Intrinsic::not_intrinsic)
-    return translateCallBase(CI, MIRBuilder);
+  if (!F || !F->isIntrinsic() || ID == Intrinsic::not_intrinsic) {
+    bool NeedEHLabel = CI.isUnwindAbort();
+    MCSymbol *BeginSymbol = nullptr;
+    if (NeedEHLabel) {
+      MIRBuilder.buildInstr(TargetOpcode::G_INVOKE_REGION_START);
+      BeginSymbol = MF->getContext().createTempSymbol();
+      MIRBuilder.buildInstr(TargetOpcode::EH_LABEL).addSym(BeginSymbol);
+    }
+    if (CI.isInlineAsm()) {
+      if (!translateInlineAsm(CI, MIRBuilder))
+        return false;
+    } else if (!translateCallBase(CI, MIRBuilder))
+      return false;
+
+    if (NeedEHLabel) {
+      MCSymbol *EndSymbol = MF->getContext().createTempSymbol();
+      MIRBuilder.buildInstr(TargetOpcode::EH_LABEL).addSym(EndSymbol);
+      MF->addInvoke(nullptr, BeginSymbol, EndSymbol);
+    }
+    return true;
+  }
 
   assert(ID != Intrinsic::not_intrinsic && "unknown intrinsic");
 
   if (translateKnownIntrinsic(CI, ID, MIRBuilder))
     return true;
 
   ArrayRef<Register> ResultRegs;
   if (!CI.getType()->isVoidTy())

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

if (const InlineAsm *IA = dyn_cast<InlineAsm>(Call->getCalledOperand())) {
 
     const MDNode *SrcLoc = Call->getMetadata("srcloc");
     if (SrcLoc)
       MIB.addMetadata(SrcLoc);
 
     return true;
   }
 
+  // Don't handle unwindabort calls yet
+  if (Call->isUnwindAbort())
+    return false;
+
   // Handle intrinsic function calls.
   if (const auto *II = dyn_cast<IntrinsicInst>(Call))
     return selectIntrinsicCall(II);
 
   return lowerCall(Call);
 }
 
 bool FastISel::selectIntrinsicCall(const IntrinsicInst *II) {

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

public:
 
   void populateCallLoweringInfo(TargetLowering::CallLoweringInfo &CLI,
                                 const CallBase *Call, unsigned ArgIdx,
                                 unsigned NumArgs, SDValue Callee,
                                 Type *ReturnTy, bool IsPatchPoint);
 
   std::pair<SDValue, SDValue>
   lowerInvokable(TargetLowering::CallLoweringInfo &CLI,
-                 const BasicBlock *EHPadBB = nullptr);
+                 const BasicBlock *EHPadBB = nullptr,
+                 bool RequireEHLabels = false);
 
   /// When an MBB was split during scheduling, update the
   /// references that need to refer to the last resulting block.
   void UpdateSplitBlock(MachineBasicBlock *First, MachineBasicBlock *Last);
 
   /// Describes a gc.statepoint or a gc.statepoint like thing for the purposes
   /// of lowering into a STATEPOINT node.
   struct StatepointLoweringInfo {
SDDbgValue *getDbgValue(SDValue N, DILocalVariable *Variable,
                           DIExpression *Expr, const DebugLoc &dl,
                           unsigned DbgSDNodeOrder);
 
   /// Lowers CallInst to an external symbol.
   void lowerCallToExternalSymbol(const CallInst &I, const char *FunctionName);
 
   SDValue lowerStartEH(SDValue Chain, const BasicBlock *EHPadBB,
                        MCSymbol *&BeginLabel);
-  SDValue lowerEndEH(SDValue Chain, const InvokeInst *II,
+  SDValue lowerEndEH(SDValue Chain, const CallBase *CB,
                      const BasicBlock *EHPadBB, MCSymbol *BeginLabel);
 };
 
 /// This struct represents the registers (physical or virtual)
 /// that a particular set of values is assigned, and the type information about
 /// the value. The most common situation is to represent one value at a time,
 /// but struct or array values are handled element-wise as multiple values.  The
 /// splitting of aggregates is performed recursively, so that we never have

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (CallSiteIndex) {
 
     // Now that the call site is handled, stop tracking it.
     MMI.setCurrentCallSite(0);
   }
 
   return DAG.getEHLabel(getCurSDLoc(), Chain, BeginLabel);
 }
 
-SDValue SelectionDAGBuilder::lowerEndEH(SDValue Chain, const InvokeInst *II,
+SDValue SelectionDAGBuilder::lowerEndEH(SDValue Chain, const CallBase *CB,
                                         const BasicBlock *EHPadBB,
                                         MCSymbol *BeginLabel) {
   assert(BeginLabel && "BeginLabel should've been set");
 
   MachineFunction &MF = DAG.getMachineFunction();
   MachineModuleInfo &MMI = MF.getMMI();
 
   // Insert a label at the end of the invoke call to mark the try range.  This
   // can be used to detect deletion of the invoke via the MachineModuleInfo.
   MCSymbol *EndLabel = MMI.getContext().createTempSymbol();
   Chain = DAG.getEHLabel(getCurSDLoc(), Chain, EndLabel);
 
   // Inform MachineModuleInfo of range.
   auto Pers = classifyEHPersonality(FuncInfo.Fn->getPersonalityFn());
   // There is a platform (e.g. wasm) that uses funclet style IR but does not
   // actually use outlined funclets and their LSDA info style.
   if (MF.hasEHFunclets() && isFuncletEHPersonality(Pers)) {
-    assert(II && "II should've been set");
+    assert(CB && "CB should've been set");
     WinEHFuncInfo *EHInfo = MF.getWinEHFuncInfo();
-    EHInfo->addIPToStateRange(II, BeginLabel, EndLabel);
+    EHInfo->addIPToStateRange(CB, BeginLabel, EndLabel);
   } else if (!isScopedEHPersonality(Pers)) {
-    assert(EHPadBB);
-    MF.addInvoke(FuncInfo.MBBMap[EHPadBB], BeginLabel, EndLabel);
+    MF.addInvoke(EHPadBB ? FuncInfo.MBBMap[EHPadBB] : nullptr, BeginLabel,
+                 EndLabel);
   }
 
   return Chain;
 }
 
 std::pair<SDValue, SDValue>
 SelectionDAGBuilder::lowerInvokable(TargetLowering::CallLoweringInfo &CLI,
-                                    const BasicBlock *EHPadBB) {
+                                    const BasicBlock *EHPadBB,
+                                    bool EmitEHLabels) {
   MCSymbol *BeginLabel = nullptr;
 
-  if (EHPadBB) {
+  if (EmitEHLabels) {
     // Both PendingLoads and PendingExports must be flushed here;
     // this call might not return.
     (void)getRoot();
     DAG.setRoot(lowerStartEH(getControlRoot(), EHPadBB, BeginLabel));
     CLI.setChain(getRoot());
   }
 
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
if (!Result.second.getNode()) {
 
     // Since there's no actual continuation from this block, nothing can be
     // relying on us setting vregs for them.
     PendingExports.clear();
   } else {
     DAG.setRoot(Result.second);
   }
 
-  if (EHPadBB) {
-    DAG.setRoot(lowerEndEH(getRoot(), cast_or_null<InvokeInst>(CLI.CB), EHPadBB,
-                           BeginLabel));
+  if (EmitEHLabels) {
+    DAG.setRoot(lowerEndEH(getRoot(), CLI.CB, EHPadBB, BeginLabel));
   }
 
   return Result;
 }
 
 void SelectionDAGBuilder::LowerCallTo(const CallBase &CB, SDValue Callee,
                                       bool isTailCall,
                                       bool isMustTailCall,
                                       const BasicBlock *EHPadBB) {
   auto &DL = DAG.getDataLayout();
   FunctionType *FTy = CB.getFunctionType();
   Type *RetTy = CB.getType();
 
   TargetLowering::ArgListTy Args;
   Args.reserve(CB.arg_size());
 
   const Value *SwiftErrorVal = nullptr;
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
 
+  // We need EH_LABELs for unwindabort call instructions and when there's an
+  // EHPadBB.
+  bool EmitEHLabels = EHPadBB != nullptr || CB.isUnwindAbort();
+
   if (isTailCall) {
     // Avoid emitting tail calls in functions with the disable-tail-calls
     // attribute.
     auto *Caller = CB.getParent()->getParent();
     if (Caller->getFnAttribute("disable-tail-calls").getValueAsString() ==
         "true" && !isMustTailCall)
       isTailCall = false;
 
void SelectionDAGBuilder::LowerCallTo(const CallBase &CB, SDValue Callee,
   CLI.setDebugLoc(getCurSDLoc())
       .setChain(getRoot())
       .setCallee(RetTy, FTy, Callee, std::move(Args), CB)
       .setTailCall(isTailCall)
       .setConvergent(CB.isConvergent())
       .setIsPreallocated(
           CB.countOperandBundlesOfType(LLVMContext::OB_preallocated) != 0)
       .setCFIType(CFIType);
-  std::pair<SDValue, SDValue> Result = lowerInvokable(CLI, EHPadBB);
+  std::pair<SDValue, SDValue> Result =
+      lowerInvokable(CLI, EHPadBB, EmitEHLabels);
 
   if (Result.first.getNode()) {
     Result.first = lowerRangeToAssertZExt(DAG, CB, Result.first);
     setValue(&CB, Result.first);
   }
 
   // The last element of CLI.InVals has the SDValue for swifterror return.
   // Here we copy it to a virtual register and update SwiftErrorMap for
for (auto &T : TargetConstraints) {
 
     ExtraInfo.update(T);
   }
 
   // We won't need to flush pending loads if this asm doesn't touch
   // memory and is nonvolatile.
   SDValue Glue, Chain = (HasSideEffect) ? getRoot() : DAG.getRoot();
 
-  bool EmitEHLabels = isa<InvokeInst>(Call);
-  if (EmitEHLabels) {
-    assert(EHPadBB && "InvokeInst must have an EHPadBB");
-  }
+  bool EmitEHLabels = isa<InvokeInst>(Call) || Call.isUnwindAbort();
   bool IsCallBr = isa<CallBrInst>(Call);
 
   if (IsCallBr || EmitEHLabels) {
     // If this is a callbr or invoke we need to flush pending exports since
     // inlineasm_br and invoke are terminators.
     // We need to do this before nodes are glued to the inlineasm_br node.
     Chain = getControlRoot();
   }
if (!ResultValues.empty()) {
     setValue(&Call, V);
   }
 
   // Collect store chains.
   if (!OutChains.empty())
     Chain = DAG.getNode(ISD::TokenFactor, getCurSDLoc(), MVT::Other, OutChains);
 
   if (EmitEHLabels) {
-    Chain = lowerEndEH(Chain, cast<InvokeInst>(&Call), EHPadBB, BeginLabel);
+    Chain = lowerEndEH(Chain, &Call, EHPadBB, BeginLabel);
   }
 
   // Only Update Root if inline assembly has a memory effect.
   if (ResultValues.empty() || HasSideEffect || !OutChains.empty() || IsCallBr ||
       EmitEHLabels)
     DAG.setRoot(Chain);
 }
 
void SelectionDAGBuilder::visitPatchpoint(const CallBase &CB,
   // For AnyRegCC the arguments are lowered later on manually.
   unsigned NumCallArgs = IsAnyRegCC ? 0 : NumArgs;
   Type *ReturnTy =
       IsAnyRegCC ? Type::getVoidTy(*DAG.getContext()) : CB.getType();
 
   TargetLowering::CallLoweringInfo CLI(DAG);
   populateCallLoweringInfo(CLI, &CB, NumMetaOpers, NumCallArgs, Callee,
                            ReturnTy, true);
-  std::pair<SDValue, SDValue> Result = lowerInvokable(CLI, EHPadBB);
+  std::pair<SDValue, SDValue> Result =
+      lowerInvokable(CLI, EHPadBB, EHPadBB || CB.isUnwindAbort());
 
   SDNode *CallEnd = Result.second.getNode();
   if (HasDef && (CallEnd->getOpcode() == ISD::CopyFromReg))
     CallEnd = CallEnd->getOperand(0).getNode();
 
   /// Get a call instruction from the call sequence chain.
   /// Tail calls are not allowed.
   assert(CallEnd->getOpcode() == ISD::CALLSEQ_END &&

llvm/lib/CodeGen/SelectionDAG/StatepointLowering.cpp

 
 /// Extract call from statepoint, lower it and return pointer to the
 /// call node. Also update NodeMap so that getValue(statepoint) will
 /// reference lowered call result
 static std::pair<SDValue, SDNode *> lowerCallFromStatepointLoweringInfo(
     SelectionDAGBuilder::StatepointLoweringInfo &SI,
     SelectionDAGBuilder &Builder) {
   SDValue ReturnValue, CallEndVal;
-  std::tie(ReturnValue, CallEndVal) =
-      Builder.lowerInvokable(SI.CLI, SI.EHPadBB);
+  std::tie(ReturnValue, CallEndVal) = Builder.lowerInvokable(
+      SI.CLI, SI.EHPadBB, SI.EHPadBB /*FIXME: || IsUnwindAbort*/);
   SDNode *CallEnd = CallEndVal.getNode();
 
   // Get a call instruction from the call sequence chain.  Tail calls are not
   // allowed.  The following code is essentially reverse engineering X86's
   // LowerCallTo.
   //
   // We are expecting DAG to have the following form:
   //

llvm/lib/CodeGen/WinEHPrepare.cpp

if (auto *UsingPHI = dyn_cast<PHINode>(UsingInst)) {
     // Reload right before the old use.
     auto *Load = new LoadInst(V->getType(), SpillSlot,
                               Twine(V->getName(), ".wineh.reload"),
                               /*isVolatile=*/false, UsingInst);
     U.set(Load);
   }
 }
 
-void WinEHFuncInfo::addIPToStateRange(const InvokeInst *II,
-                                      MCSymbol *InvokeBegin,
+void WinEHFuncInfo::addIPToStateRange(const CallBase *CB, MCSymbol *InvokeBegin,
                                       MCSymbol *InvokeEnd) {
+  // TODO: implement support for 'call unwindabort' in WinEH
+  const InvokeInst *II = dyn_cast<InvokeInst>(CB);
+  if (!II)
+    return;
+
   assert(InvokeStateMap.count(II) &&
          "should get invoke with precomputed state");
   LabelToStateMap[InvokeBegin] = std::make_pair(InvokeStateMap[II], InvokeEnd);
 }
 
 void WinEHFuncInfo::addIPToStateRange(int State, MCSymbol* InvokeBegin,
     MCSymbol* InvokeEnd) {
     LabelToStateMap[InvokeBegin] = std::make_pair(State, InvokeEnd);
 }
 
 WinEHFuncInfo::WinEHFuncInfo() = default;

llvm/test/CodeGen/AArch64/GlobalISel/call-translator-tail-call.ll

 ; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
 ; RUN: llc %s -stop-after=irtranslator -verify-machineinstrs -mtriple aarch64-apple-darwin -global-isel -o - 2>&1 | FileCheck %s --check-prefix=DARWIN
 ; RUN: llc %s -stop-after=irtranslator -verify-machineinstrs -mtriple aarch64-windows -global-isel -o - 2>&1 | FileCheck %s --check-prefix=WINDOWS
 
+declare i32 @__gxx_personality_v0(...)
+
 declare void @simple_fn()
 define void @tail_call() {
   ; DARWIN-LABEL: name: tail_call
   ; DARWIN: bb.1 (%ir-block.0):
   ; DARWIN-NEXT:   TCRETURNdi @simple_fn, 0, csr_darwin_aarch64_aapcs, implicit $sp
   ; WINDOWS-LABEL: name: tail_call
   ; WINDOWS: bb.1 (%ir-block.0):
   ; WINDOWS-NEXT:   TCRETURNdi @simple_fn, 0, csr_aarch64_aapcs, implicit $sp
   tail call void @simple_fn()
   ret void
 }
 
+; We cannot tail-call when unwindabort is required.
+define void @no_tail_call_unwindabort() personality ptr @__gxx_personality_v0 {
+  ; DARWIN-LABEL: name: no_tail_call_unwindabort
+  ; DARWIN: bb.1 (%ir-block.0):
+  ; DARWIN-NEXT:   G_INVOKE_REGION_START
+  ; DARWIN-NEXT:   EH_LABEL <mcsymbol >
+  ; DARWIN-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $sp, implicit $sp
+  ; DARWIN-NEXT:   BL @simple_fn, csr_darwin_aarch64_aapcs, implicit-def $lr, implicit $sp
+  ; DARWIN-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
+  ; DARWIN-NEXT:   EH_LABEL <mcsymbol >
+  ; DARWIN-NEXT:   RET_ReallyLR
+  ; WINDOWS-LABEL: name: no_tail_call_unwindabort
+  ; WINDOWS: bb.1 (%ir-block.0):
+  ; WINDOWS-NEXT:   G_INVOKE_REGION_START
+  ; WINDOWS-NEXT:   EH_LABEL <mcsymbol >
+  ; WINDOWS-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $sp, implicit $sp
+  ; WINDOWS-NEXT:   BL @simple_fn, csr_aarch64_aapcs, implicit-def $lr, implicit $sp
+  ; WINDOWS-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $sp, implicit $sp
+  ; WINDOWS-NEXT:   EH_LABEL <mcsymbol >
+  ; WINDOWS-NEXT:   RET_ReallyLR
+  tail call unwindabort void @simple_fn()
+  ret void
+}
+
 ; We should get a TCRETURNri here.
 ; FIXME: We don't need the COPY.
 define void @indirect_tail_call(ptr %func) {
   ; DARWIN-LABEL: name: indirect_tail_call
   ; DARWIN: bb.1 (%ir-block.0):
   ; DARWIN-NEXT:   liveins: $x0
   ; DARWIN-NEXT: {{  $}}
   ; DARWIN-NEXT:   [[COPY:%[0-9]+]]:tcgpr64(p0) = COPY $x0

llvm/test/CodeGen/AArch64/call-unwindabort-codegen.ll

+; RUN: llc -mtriple=aarch64-unknown-linux-gnu -global-isel=0 -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -mtriple=aarch64-unknown-linux-gnu -global-isel=1 -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -mtriple=aarch64-unknown-linux-gnu -global-isel=0 -fast-isel=1 < %s | FileCheck %s
+
+declare void @throws()
+
+define dso_local void @test() personality ptr @__gxx_personality_v0 {
+entry:
+; CHECK-LABEL: test:
+; CHECK:      .Ltmp0:
+; CHECK-NEXT: bl throws
+; CHECK-NEXT: .Ltmp1:
+
+  call unwindabort void @throws()
+  ret void
+}
+
+declare dso_local i32 @__gxx_personality_v0(...)
+
+; Exception table generation around the inline assembly
+
+; CHECK-LABEL: GCC_except_table0:
+; CHECK-NEXT: .Lexception0:
+; CHECK-NEXT:  .byte 255                             // @LPStart Encoding = omit
+; CHECK-NEXT:  .byte 255                             // @TType Encoding = omit
+; CHECK-NEXT:  .byte 1                               // Call site Encoding = uleb128
+; CHECK-NEXT:  .uleb128 .Lcst_end0-.Lcst_begin0
+; CHECK-NEXT: .Lcst_begin0:
+; CHECK-NEXT: .Lcst_end0:

llvm/test/CodeGen/AArch64/unwindabort-inline-asm-codegen.ll

+; RUN: llc -mtriple=aarch64-unknown-linux-gnu -global-isel=0 -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -mtriple=aarch64-unknown-linux-gnu -global-isel=1 -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -mtriple=aarch64-unknown-linux-gnu -global-isel=0 -fast-isel=1 < %s | FileCheck %s
+
+define dso_local void @test() personality ptr @__gxx_personality_v0 {
+entry:
+; CHECK-LABEL: test:
+; CHECK:      .Ltmp0:
+; CHECK-NEXT: //APP
+; CHECK-NEXT: nop
+; CHECK-NEXT: //NO_APP
+; CHECK-NEXT: .Ltmp1:
+
+  call unwindabort void asm sideeffect unwind "nop", "~{dirflag},~{fpsr},~{flags}"()
+  ret void
+}
+
+declare dso_local i32 @__gxx_personality_v0(...)
+
+; Exception table generation around the inline assembly
+
+; CHECK-LABEL: GCC_except_table0:
+; CHECK-NEXT: .Lexception0:
+; CHECK-NEXT:  .byte 255                             // @LPStart Encoding = omit
+; CHECK-NEXT:  .byte 255                             // @TType Encoding = omit
+; CHECK-NEXT:  .byte 1                               // Call site Encoding = uleb128
+; CHECK-NEXT:  .uleb128 .Lcst_end0-.Lcst_begin0
+; CHECK-NEXT: .Lcst_begin0:
+; CHECK-NEXT: .Lcst_end0:

llvm/test/CodeGen/X86/call-unwindabort-codegen.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -fast-isel=1 < %s | FileCheck %s
+
+declare void @throws()
+
+define dso_local void @test() personality ptr @__gxx_personality_v0 {
+entry:
+; CHECK-LABEL: test:
+; CHECK:      .Ltmp0:
+; CHECK-NEXT: callq throws@PLT
+; CHECK-NEXT: .Ltmp1:
+
+  call unwindabort void @throws()
+  ret void
+}
+
+declare dso_local i32 @__gxx_personality_v0(...)
+
+; Exception table generation around the inline assembly
+
+
+; CHECK-LABEL: GCC_except_table0:
+; CHECK-NEXT: .Lexception0:
+; CHECK-NEXT:  .byte 255                             # @LPStart Encoding = omit
+; CHECK-NEXT:  .byte 255                             # @TType Encoding = omit
+; CHECK-NEXT:  .byte 1                               # Call site Encoding = uleb128
+; CHECK-NEXT:  .uleb128 .Lcst_end0-.Lcst_begin0
+; CHECK-NEXT: .Lcst_begin0:
+; CHECK-NEXT: .Lcst_end0:

llvm/test/CodeGen/X86/eh-callsites.ll

+; RUN: llc -mtriple=x86_64-linux-gnu -global-isel=0 -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -mtriple=x86_64-linux-gnu -global-isel=1 -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -mtriple=x86_64-linux-gnu -global-isel=0 -fast-isel=1 < %s | FileCheck %s
+
+;; These tests verify that we construct proper LSDA call-site tables for the normal DWARF personality style.
+
+declare void @throw()
+declare void @nothrow() #0
+
+declare i32 @__gxx_personality_v0(...)
+
+;; A function with only unwindabort should generate an empty callsite
+;; table in the LSDA.
+; CHECK-LABEL: abort_only:
+; CHECK:         .cfi_personality 3, __gxx_personality_v0
+; CHECK:         .cfi_lsda 3, [[EXTABLE:.Lexception[0-9]+]]
+; CHECK:         callq throw
+; CHECK:       [[EXTABLE]]:
+; CHECK-NEXT:    .byte   255                     # @LPStart Encoding = omit
+; CHECK-NEXT:    .byte   255                     # @TType Encoding = omit
+; CHECK-NEXT:    .byte   1                       # Call site Encoding = uleb128
+; CHECK-NEXT:    .uleb128 [[CST_END:.Lcst_end[0-9]+]]-[[CST_BEGIN:.Lcst_begin[0-9]+]]
+; CHECK-NEXT:  [[CST_BEGIN]]:
+; CHECK-NEXT:  [[CST_END]]:
+define void @abort_only() personality ptr @__gxx_personality_v0 {
+entry:
+  call unwindabort void @throw()
+  unreachable
+}
+
+;; A function with only a potentially-throwing calls should not
+;; generate any LSDA at all.
+; CHECK-LABEL: throwing_call_only:
+; CHECK-NOT:   .cfi_personality
+; CHECK-NOT:   .cfi_lsda
+; CHECK:       callq throw
+define void @throwing_call_only() personality ptr @__gxx_personality_v0 {
+entry:
+  call void @throw()
+  unreachable
+}
+
+;; Here, we have some unwindabort calls, some plain calls that unwind
+;; out of the function, and some interspersed calls to nounwind
+;; functions.
+;; - The potentially-unwinding callsite must be included in the
+;;   callsite table.
+;; - The unwindabort callsite must NOT be included in the table.
+;; - Nounwind callsites can be included into any region, whatever's convenient.
+
+; CHECK-LABEL: interspersed_nounwinds:
+; CHECK:       [[BEGIN:.Lfunc_begin[0-9]+]]:
+; CHECK:         .cfi_personality 3, __gxx_personality_v0
+; CHECK:         .cfi_lsda 3, [[EXTABLE:.Lexception[0-9]+]]
+; CHECK:       [[TMP1:.Ltmp[0-9]+]]:
+; CHECK-NEXT:    callq throw
+; CHECK-NEXT:  [[TMP2:.Ltmp[0-9]+]]:
+; CHECK-NEXT:    callq nothrow
+; CHECK-NEXT:  [[TMP3:.Ltmp[0-9]+]]:
+; CHECK-NEXT:    callq throw
+; CHECK-NEXT:  [[TMP4:.Ltmp[0-9]+]]:
+; CHECK-NEXT:    callq throw
+; CHECK-NEXT:    callq nothrow
+; CHECK-NEXT:    callq throw
+; CHECK-NEXT:  [[END:.Lfunc_end[0-9]+]]:
+; CHECK:       [[EXTABLE]]
+; CHECK-NEXT:    .byte  255                             # @LPStart Encoding = omit
+; CHECK-NEXT:    .byte  255                             # @TType Encoding = omit
+; CHECK-NEXT:    .byte  1                               # Call site Encoding = uleb128
+; CHECK-NEXT:    .uleb128 [[CST_END:.Lcst_end[0-9]+]]-[[CST_BEGIN:.Lcst_begin[0-9]+]]
+; CHECK-NEXT:  [[CST_BEGIN]]:
+; CHECK-NEXT:    .uleb128 [[TMP4]]-[[BEGIN]]            # >> Call Site 1 <<
+; CHECK-NEXT:    .uleb128 [[END]]-[[TMP4]]              #   Call between [[TMP4]] and [[END]]
+; CHECK-NEXT:    .byte  0                               #     has no landing pad
+; CHECK-NEXT:    .byte  0                               #   On action: cleanup
+; CHECK-NEXT:  [[CST_END]]:
+
+
+define void @interspersed_nounwinds() personality ptr @__gxx_personality_v0 {
+entry:
+  call unwindabort void @throw()
+  call void @nothrow() #0
+  call unwindabort void @throw()
+
+  call void @throw()
+  call void @nothrow() #0
+  call void @throw()
+  unreachable
+}
+
+;; This tests the LSDA callsite and action maps resulting from various sorts of invoke landingpads are appropriate.
+;;
+
+; CHECK-LABEL: invokes:
+; CHECK:       [[BEGIN:.Lfunc_begin[0-9]+]]:
+; CHECK:         .cfi_personality 3, __gxx_personality_v0
+; CHECK:         .cfi_lsda 3, [[EXTABLE:.Lexception[0-9]+]]
+; CHECK:       [[TMP1:.Ltmp[0-9]+]]:
+; CHECK-NEXT:    callq throw
+; CHECK-NEXT:  [[TMP2:.Ltmp[0-9]+]]:
+; CHECK:       [[TMP3:.Ltmp[0-9]+]]:
+; CHECK-NEXT:    callq throw
+; CHECK-NEXT:  [[TMP4:.Ltmp[0-9]+]]:
+; CHECK:       [[TMP5:.Ltmp[0-9]+]]:
+; CHECK-NEXT:    callq throw
+; CHECK-NEXT:  [[TMP6:.Ltmp[0-9]+]]:
+; CHECK:         callq _Unwind_Resume
+; CHECK:       [[TMP7:.Ltmp[0-9]+]]:
+; CHECK-NEXT:  [[TMP8:.Ltmp[0-9]+]]:
+; CHECK:         callq _Unwind_Resume
+; CHECK:       [[END:.Lfunc_end[0-9]+]]:
+; CHECK:       [[EXTABLE]]:
+; CHECK-NEXT:    .byte  255                             # @LPStart Encoding = omit
+; CHECK-NEXT:    .byte  3                               # @TType Encoding = udata4
+; CHECK-NEXT:    .uleb128 [[TTBASE:.Lttbase[0-9]+]]-[[TTBASEREF:.Lttbaseref[0-9]+]]
+; CHECK-NEXT:  [[TTBASEREF]]:
+; CHECK-NEXT:    .byte  1                               # Call site Encoding = uleb128
+; CHECK-NEXT:    .uleb128 [[CST_END:.Lcst_end[0-9]+]]-[[CST_BEGIN:.Lcst_begin[0-9]+]]
+; CHECK-NEXT:  [[CST_BEGIN]]:
+; CHECK-NEXT:    .uleb128 [[TMP1]]-[[BEGIN]]            # >> Call Site 1 <<
+; CHECK-NEXT:    .uleb128 [[TMP2]]-[[TMP1]]             #   Call between [[TMP1]] and [[TMP2]]
+; CHECK-NEXT:    .uleb128 {{.Ltmp[0-9]+}}-[[BEGIN]]     #     jumps to {{.Ltmp[0-9]+}}
+; CHECK-NEXT:    .byte  3                               #   On action: 2
+; CHECK-NEXT:    .uleb128 [[TMP3]]-[[BEGIN]]            # >> Call Site 2 <<
+; CHECK-NEXT:    .uleb128 [[TMP4]]-[[TMP3]]             #   Call between [[TMP3]] and [[TMP4]]
+; CHECK-NEXT:    .uleb128 {{.Ltmp[0-9]+}}-[[BEGIN]]     #     jumps to {{.Ltmp[0-9]+}}
+; CHECK-NEXT:    .byte  0                               #   On action: cleanup
+; CHECK-NEXT:    .uleb128 [[TMP5]]-[[BEGIN]]            # >> Call Site 3 <<
+; CHECK-NEXT:    .uleb128 [[TMP6]]-[[TMP5]]             #   Call between [[TMP5]] and [[TMP6]]
+; CHECK-NEXT:    .uleb128 {{.Ltmp[0-9]+}}-[[BEGIN]]     #     jumps to {{.Ltmp[0-9]+}}
+; CHECK-NEXT:    .byte  5                               #   On action: 3
+; CHECK-NEXT:    .uleb128 [[TMP6]]-[[BEGIN]]            # >> Call Site 4 <<
+; CHECK-NEXT:    .uleb128 [[TMP8]]-[[TMP6]]             #   Call between [[TMP6]] and [[TMP8]]
+; CHECK-NEXT:    .byte  0                               #     has no landing pad
+; CHECK-NEXT:    .byte  0                               #   On action: cleanup
+; CHECK-NEXT:  [[CST_END]]:
+; CHECK-NEXT:    .byte  0                               # >> Action Record 1 <<
+; CHECK-NEXT:                                           #   Cleanup
+; CHECK-NEXT:    .byte  0                               #   No further actions
+; CHECK-NEXT:    .byte  1                               # >> Action Record 2 <<
+; CHECK-NEXT:                                           #   Catch TypeInfo 1
+; CHECK-NEXT:    .byte  125                             #   Continue to action 1
+; CHECK-NEXT:    .byte  1                               # >> Action Record 3 <<
+; CHECK-NEXT:                                           #   Catch TypeInfo 1
+; CHECK-NEXT:    .byte  0                               #   No further actions
+; CHECK-NEXT:    .p2align  2
+; CHECK-NEXT:                                           # >> Catch TypeInfos <<
+; CHECK-NEXT:    .long  0                               # TypeInfo 1
+; CHECK-NEXT:  [[TTBASE]]:
+
+define void @invokes(i8 %x) personality ptr @__gxx_personality_v0 {
+entry:
+  switch i8 %x, label %one [ i8 0, label %two
+                             i8 1, label %three ]
+one:
+  invoke void @throw()
+          to label %cont unwind label %catch
+two:
+  invoke void @throw()
+          to label %cont unwind label %cleanup
+three:
+  invoke void @throw()
+          to label %cont unwind label %catch_cleanup
+
+cont:
+  ret void
+
+catch:
+  %0 = landingpad { ptr, i32 }
+          catch ptr null
+  ret void
+
+cleanup:
+  %1 = landingpad { ptr, i32 }
+          cleanup
+  resume { ptr, i32 } %1
+catch_cleanup:
+  %2 = landingpad { ptr, i32 }
+          cleanup
+          catch ptr null
+  resume unwindabort { ptr, i32 } %2
+}
+
+attributes #0 = { nounwind }

llvm/test/CodeGen/X86/indirect-branch-tracking-eh2.ll

 ; RUN: llc -mtriple x86_64-unknown-unknown -exception-model sjlj -verify-machineinstrs=0 -simplifycfg-require-and-preserve-domtree=1 < %s | FileCheck %s --check-prefix=NUM
 ; RUN: llc -mtriple x86_64-unknown-unknown -exception-model sjlj -verify-machineinstrs=0 -simplifycfg-require-and-preserve-domtree=1 < %s | FileCheck %s --check-prefix=SJLJ
 
 ; NUM-COUNT-3: endbr64
 
 ;SJLJ:       main:                                  # @main
 ;SJLJ-NEXT: .Lfunc_begin0:
 ;SJLJ-NEXT: # %bb.0:                                # %entry
 ;SJLJ-NEXT:         endbr64
 ;SJLJ-NEXT:         pushq   %rbp
 ;SJLJ:               callq   _Unwind_SjLj_Register
-;SJLJ-NEXT: .Ltmp0:
+;SJLJ:      .Ltmp0:
 ;SJLJ-NEXT:         callq   _Z3foov
 ;SJLJ-NEXT: .Ltmp1:
 ;SJLJ-NEXT: # %bb.1:                                # %invoke.cont
 ;SJLJ-NEXT:         movl
 ;SJLJ-NEXT: .LBB0_7:                                # %return
 ;SJLJ:               callq   _Unwind_SjLj_Unregister
 ;SJLJ:               retq
 ;SJLJ-NEXT: .LBB0_9:

llvm/test/CodeGen/X86/unwind-inline-asm-codegen.ll

 ; RUN: llc < %s | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @.str.2 = private unnamed_addr constant [7 x i8] c"Boom!\0A\00", align 1
 
 define dso_local void @trap() {
 entry:
   unreachable
 }
 
 define dso_local void @test() personality ptr @__gxx_personality_v0 {
 entry:
-
-; CHECK-LABEL: .Ltmp0:
+; CHECK-LABEL: test:
+; CHECK: .Ltmp0:
 ; CHECK: callq  trap
-; CHECK-LABEL: .Ltmp1:
+; CHECK: .Ltmp1:
 
   invoke void asm sideeffect unwind "call trap", "~{dirflag},~{fpsr},~{flags}"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret void
 
 lpad:

llvm/test/CodeGen/X86/unwindabort-inline-asm-codegen.ll

+; RUN: llc -fast-isel=0 < %s | FileCheck %s
+; RUN: llc -fast-isel=1 < %s | FileCheck %s
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local void @test() personality ptr @__gxx_personality_v0 {
+entry:
+; CHECK-LABEL: test:
+; CHECK:      .Ltmp0:
+; CHECK-NEXT: #APP
+; CHECK-NEXT: nop
+; CHECK-NEXT: #NO_APP
+; CHECK-NEXT: .Ltmp1:
+
+  call unwindabort void asm sideeffect unwind "nop", "~{dirflag},~{fpsr},~{flags}"()
+  ret void
+}
+
+declare dso_local i32 @__gxx_personality_v0(...)
+
+; Exception table generation around the inline assembly.
+
+; CHECK-LABEL: GCC_except_table0:
+; CHECK-NEXT: .Lexception0:
+; CHECK-NEXT:   .byte 255                             # @LPStart Encoding = omit
+; CHECK-NEXT:   .byte 255                             # @TType Encoding = omit
+; CHECK-NEXT:   .byte 1                               # Call site Encoding = uleb128
+; CHECK-NEXT:   .uleb128 .Lcst_end0-.Lcst_begin0
+; CHECK-NEXT: .Lcst_begin0:
+; CHECK-NEXT: .Lcst_end0: