WIP: Unwindabort: add support for IR transforms and analysis.

[jyknight]

Summary

This is part of a series of changes to enable generating more
efficient code for C++ "noexcept" functions. See also the RFC,
https://discourse.llvm.org/t/rfc-add-call-unwindabort-to-llvm-ir/62543

In previous commits, we added the core Instruction support for
'unwindabort'. This commit adds support for its semantics to the
IR-level transforms and analyses.

Depends on D141915

[lebedev.ri]

llvm/include/llvm/Transforms/Utils/Local.h

357

?

358

llvm/test/Instrumentation/ThreadSanitizer/eh.ll

1

Please precommit all such regenerations

[lebedev.ri]

This is missing a very important correctness change to haveSameSpecialState()/FunctionComparator::cmpOperations()

[barannikov88]

llvm/test/Transforms/FunctionAttrs/nounwind.ll

85

_could_ it be marked nounwind?

In general -- no. One has to prove that the destructor of the caught exception does not throw.

[jroelofs]

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

1612

I don't understand the choice of the word "may" here. Isn't an unwind through an unwindabort supposed to /always/ lead to an abort?

llvm/lib/Transforms/Utils/InlineFunction.cpp

2401–2404

llvm/lib/Transforms/Utils/Local.cpp

2595

[jroelofs]

llvm/include/llvm/Transforms/Utils/Local.h

365–367

[jyknight]

Rebase patch.

[jyknight]

In D141916#4059553, @lebedev.ri wrote:

This is missing a very important correctness change to haveSameSpecialState()/FunctionComparator::cmpOperations()

Yikes -- thanks for pointing that out. It's quite unfortunate that we hide equality and comparisons for Instruction types in 2 other non-obvious places. It'd be great to move all of that into methods _on_ the type, so it's more obvious that it needs to be changed when adding data to an instruction. It looks like I don't need to change FunctionComparator, since it just generically checks getRawSubclassData() for equality. But, I do need to modify hasSameSpecialState, since it does not do so (yikes^2 that these functions differ in that way!).

I'll add those changes to into the previous 3 patches in this series.

llvm/include/llvm/Transforms/Utils/Local.h

357

I'll keep the current name, in order to make clear this enum is intended to be specific for this function's argument, rather than general-purpose.

llvm/test/Transforms/FunctionAttrs/nounwind.ll

85

Ah, right. TODO removed, explanation added.

llvm/include/llvm/Analysis/EHPersonalities.h

case EHPersonality::Wasm_CXX:
     return true;
   default:
     return false;
   }
   llvm_unreachable("invalid enum");
 }
 
 /// Return true if this personality may be safely removed if there
-/// are no invoke instructions remaining in the current function.
+/// are no invoke/unwindabort instructions remaining in the current function.
 inline bool isNoOpWithoutInvoke(EHPersonality Pers) {
   switch (Pers) {
   case EHPersonality::Unknown:
     return false;
-  // All known personalities currently have this behavior
+  // All known personalities currently have no effect without an 'invoke' or
+  // 'call unwindabort' in the function.
   default:
     return true;
   }
   llvm_unreachable("invalid enum");
 }
 
 bool canSimplifyInvokeNoUnwind(const Function *F);
 

llvm/include/llvm/Transforms/Utils/Local.h

 /// Convert the CallInst to InvokeInst with the specified unwind edge basic
 /// block.  This also splits the basic block where CI is located, because
 /// InvokeInst is a terminator instruction.  Returns the newly split basic
 /// block.
 BasicBlock *changeToInvokeAndSplitBasicBlock(CallInst *CI,
                                              BasicBlock *UnwindEdge,
                                              DomTreeUpdater *DTU = nullptr);
 
+enum class RemoveUnwindEdgeMode {
+  Normal,
+  Nounwind,
+  Unwindabort,
+};
+
 /// Replace 'BB's terminator with one that does not have an unwind successor
 /// block. Rewrites `invoke` to `call`, etc. Updates any PHIs in unwind
 /// successor. Returns the instruction that replaced the original terminator,
 /// which might be a call in case the original terminator was an invoke.
 ///
 /// \param BB  Block whose terminator will be replaced.  Its terminator must
 ///            have an unwind successor.
-Instruction *removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU = nullptr);
+/// \param Mode Is the edge known to be 'nounwind' or 'unwindabort'?  (set if
+///             e.g. the unwind edge is known to be unreachable/reaches a
+///             'resume unwindabort')
+void removeUnwindEdge(BasicBlock *BB, RemoveUnwindEdgeMode Mode,
+                      DomTreeUpdater *DTU = nullptr);
 
 /// Remove all blocks that can not be reached from the function's entry.
 ///
 /// Returns true if any basic block was removed.
 bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU = nullptr,
                              MemorySSAUpdater *MSSAU = nullptr);
 
 /// Combine the metadata of two instructions so that K can replace J. Some

llvm/lib/CodeGen/WinEHPrepare.cpp

for (BasicBlock *BB : BlocksInFunclet) {
         auto *CalledFn =
             dyn_cast<Function>(CB->getCalledOperand()->stripPointerCasts());
         if (CalledFn && ((CalledFn->isIntrinsic() && CB->doesNotThrow()) ||
                          CB->isInlineAsm()))
           continue;
 
         // This call site was not part of this funclet, remove it.
         if (isa<InvokeInst>(CB)) {
-          // Remove the unwind edge if it was an invoke.
-          removeUnwindEdge(BB);
+          // First remove the unwind edge and convert the invoke to a
+          // call. Then...delete the call.
+          removeUnwindEdge(BB, RemoveUnwindEdgeMode::Normal);
           // Get a pointer to the new call.
           BasicBlock::iterator CallI =
               std::prev(BB->getTerminator()->getIterator());
           auto *CI = cast<CallInst>(&*CallI);
           changeToUnreachable(CI);
         } else {
           changeToUnreachable(&I);
         }
for (BasicBlock *BB : BlocksInFunclet) {
       if (IsUnreachableRet || IsUnreachableCatchret ||
           IsUnreachableCleanupret) {
         changeToUnreachable(TI);
       } else if (isa<InvokeInst>(TI)) {
         if (Personality == EHPersonality::MSVC_CXX && CleanupPad) {
           // Invokes within a cleanuppad for the MSVC++ personality never
           // transfer control to their unwind edge: the personality will
           // terminate the program.
-          removeUnwindEdge(BB);
+          //
+          // TODO: switch this to RemoveUnwindEdgeMode::Unwindabort when
+          // adding WinEH unwindabort support.
+          removeUnwindEdge(BB, RemoveUnwindEdgeMode::Normal);
         }
       }
     }
   }
 }
 
 void WinEHPrepare::cleanupPreparedFunclets(Function &F) {
   // Clean-up some of the mess we made by removing useles PHI nodes, trivial

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

ChangeStatus updateImpl(Attributor &A) override {
     auto Opcodes = {
         (unsigned)Instruction::Invoke,      (unsigned)Instruction::CallBr,
         (unsigned)Instruction::Call,        (unsigned)Instruction::CleanupRet,
         (unsigned)Instruction::CatchSwitch, (unsigned)Instruction::Resume};
 
     auto CheckForNoUnwind = [&](Instruction &I) {
       if (!I.mayThrow())
         return true;
-
+      if (auto *CI = dyn_cast<CallInst>(&I); CI && CI->isUnwindAbort())
+        return true;
       if (const auto *CB = dyn_cast<CallBase>(&I)) {
         const auto &NoUnwindAA = A.getAAFor<AANoUnwind>(
             *this, IRPosition::callsite_function(*CB), DepClassTy::REQUIRED);
         return NoUnwindAA.isAssumedNoUnwind();
       }
       return false;
     };
 
struct AAWillReturnImpl : public AAWillReturn {
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ false))
       return ChangeStatus::UNCHANGED;
 
     auto CheckForWillReturn = [&](Instruction &I) {
-      IRPosition IPos = IRPosition::callsite_function(cast<CallBase>(I));
+      CallBase &CB = cast<CallBase>(I);
+      // If the call is marked unwindabort, an unwind may be converted into an
+      // abort, so we can't deduce willreturn for the containing function.
+      if (CB.isUnwindAbort())
+        return false;
+
+      IRPosition IPos = IRPosition::callsite_function(CB);
       const auto &WillReturnAA =
           A.getAAFor<AAWillReturn>(*this, IPos, DepClassTy::REQUIRED);
       if (WillReturnAA.isKnownWillReturn())
         return true;
       if (!WillReturnAA.isAssumedWillReturn())
         return false;
       const auto &NoRecurseAA =
           A.getAAFor<AANoRecurse>(*this, IPos, DepClassTy::REQUIRED);

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

return CB && CB->isConvergent() &&
          !SCCNodes.contains(CB->getCalledFunction());
 }
 
 /// Helper for NoUnwind inference predicate InstrBreaksAttribute.
 static bool InstrBreaksNonThrowing(Instruction &I, const SCCNodeSet &SCCNodes) {
   if (!I.mayThrow())
     return false;
   if (const auto *CI = dyn_cast<CallInst>(&I)) {
+    if (CI->isUnwindAbort())
+      return false;
     if (Function *Callee = CI->getCalledFunction()) {
       // I is a may-throw call to a function inside our SCC. This doesn't
       // invalidate our current working assumption that the SCC is no-throw; we
       // just have to scan that other function.
       if (SCCNodes.contains(Callee))
         return false;
     }
   }
static bool functionWillReturn(const Function &F) {
   // Functions with loops require more sophisticated analysis, as the loop
   // may be infinite. For now, don't try to handle them.
   SmallVector<std::pair<const BasicBlock *, const BasicBlock *>> Backedges;
   FindFunctionBackedges(F, Backedges);
   if (!Backedges.empty())
     return false;
 
   // If there are no loops, then the function is willreturn if all calls in
-  // it are willreturn.
+  // it are willreturn but not unwindabort.
   return all_of(instructions(F), [](const Instruction &I) {
-    return I.willReturn();
+    if (!I.willReturn())
+      return false;
+    // If the call is marked unwindabort, an unwind may be converted into an
+    // abort, so we can't deduce willreturn for the containing function.
+    if (const CallBase *Call = dyn_cast<CallBase>(&I)) {
+      if (Call->isUnwindAbort())
+        return false;
+    }
+    return true;
   });
 }
 
 // Set the willreturn function attribute if possible.
 static void addWillReturn(const SCCNodeSet &SCCNodes,
                           SmallSet<Function *, 8> &Changed) {
   for (Function *F : SCCNodes) {
     if (!F || F->willReturn() || !functionWillReturn(*F))

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumeBundleQueries.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
   // but will result in the following folds being skipped.
   if (!CI.use_empty())
     if (Value *V = simplifyCall(&CI, SQ.getWithInstruction(&CI)))
       return replaceInstUsesWith(CI, V);
 
   if (Value *FreedOp = getFreedOperand(&CI, &TLI))
     return visitFree(CI, FreedOp);
 
-  // If the caller function (i.e. us, the function that contains this CallInst)
-  // is nounwind, mark the call as nounwind, even if the callee isn't.
-  if (CI.getFunction()->doesNotThrow() && !CI.doesNotThrow()) {
+  // If the caller function (i.e. the function containing this CallInst) is
+  // nounwind, and the call is not unwindabort, mark the call as nounwind, even
+  // when the callee function isn't.
+  if (CI.getFunction()->doesNotThrow() && !CI.isUnwindAbort() &&
+      !CI.doesNotThrow()) {
     CI.setDoesNotThrow();
     return &CI;
   }
 
+  // If the call is unwindabort and nounwind (and if nounwind _actually_ means
+  // there can't be any unwinds...), then we can remove the 'unwindabort'.
+  if (CI.isUnwindAbort() && CI.doesNotThrow() &&
+      canSimplifyInvokeNoUnwind(CI.getFunction())) {
+    CI.setUnwindAbort(false);
+    return &CI;
+  }
+
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI);
   if (!II) return visitCallBase(CI);
 
   // For atomic unordered mem intrinsics if len is not a positive or
   // not a multiple of element size then behavior is undefined.
   if (auto *AMI = dyn_cast<AtomicMemIntrinsic>(II))
     if (ConstantInt *NumBytes = dyn_cast<ConstantInt>(AMI->getLength()))
       if (NumBytes->getSExtValue() < 0 ||

llvm/lib/Transforms/Utils/EscapeEnumerator.cpp

static FunctionCallee getDefaultPersonalityFn(Module *M) {
   return M->getOrInsertFunction(getEHPersonalityName(Pers),
                                 FunctionType::get(Type::getInt32Ty(C), true));
 }
 
 IRBuilder<> *EscapeEnumerator::Next() {
   if (Done)
     return nullptr;
 
-  // Find all 'return', 'resume', and 'unwind' instructions.
+  // Find all 'return', and 'resume' (but not 'resume unwindabort')
+  // instructions; these instructions may transfer control to the calling
+  // function.
   while (StateBB != StateE) {
     BasicBlock *CurBB = &*StateBB++;
 
-    // Branches and invokes do not escape, only unwind, resume, and return
-    // do.
     Instruction *TI = CurBB->getTerminator();
-    if (!isa<ReturnInst>(TI) && !isa<ResumeInst>(TI))
+    if (!(isa<ReturnInst>(TI) ||
+          (isa<ResumeInst>(TI) && !cast<ResumeInst>(TI)->isUnwindAbort())))
       continue;
 
     if (CallInst *CI = CurBB->getTerminatingMustTailCall())
       TI = CI;
     Builder.SetInsertPoint(TI);
     return &Builder;
   }
 
   Done = true;
 
   if (!HandleExceptions)
     return nullptr;
 
   if (F.doesNotThrow())
     return nullptr;
 
-  // Find all 'call' instructions that may throw.
-  // We cannot tranform calls with musttail tag.
+  // Find all 'call' instructions that may unwind to the calling function.
+  // We cannot tranform calls with musttail tag, but it is handled above.
   SmallVector<Instruction *, 16> Calls;
   for (BasicBlock &BB : F)
     for (Instruction &II : BB)
       if (CallInst *CI = dyn_cast<CallInst>(&II))
-        if (!CI->doesNotThrow() && !CI->isMustTailCall())
+        if (!CI->isUnwindAbort() && !CI->doesNotThrow() &&
+            !CI->isMustTailCall())
           Calls.push_back(CI);
 
   if (Calls.empty())
     return nullptr;
 
   // Create a cleanup block.
   LLVMContext &C = F.getContext();
   BasicBlock *CleanupBB = BasicBlock::Create(C, CleanupBBName, &F);

llvm/lib/Transforms/Utils/InlineFunction.cpp

for (int i = 0, e = CB.getNumOperandBundles(); i != e; ++i) {
         continue;
       if (Tag == LLVMContext::OB_kcfi)
         continue;
 
       return InlineResult::failure("unsupported operand bundle");
     }
   }
 
-  // If the call to the callee cannot throw, set the 'nounwind' flag on any
-  // calls that we inline.
   bool MarkNoUnwind = CB.doesNotThrow();
+  bool MarkUnwindAbort = CB.isUnwindAbort();
 
   BasicBlock *OrigBB = CB.getParent();
   Function *Caller = OrigBB->getParent();
 
   // Do not inline strictfp function into non-strictfp one. It would require
   // conversion of all FP operations in host function to constrained intrinsics.
   if (CalledFunc->getAttributes().hasFnAttr(Attribute::StrictFP) &&
       !Caller->getAttributes().hasFnAttr(Attribute::StrictFP)) {
if (InlinedFunctionInfo.ContainsCalls) {
 
     // For inlining purposes, the "notail" marker is the same as no marker.
     if (CallSiteTailKind == CallInst::TCK_NoTail)
       CallSiteTailKind = CallInst::TCK_None;
 
     for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
          ++BB) {
       for (Instruction &I : llvm::make_early_inc_range(*BB)) {
+        if (ResumeInst *RI = dyn_cast<ResumeInst>(&I)) {
+          if (MarkUnwindAbort)
+            RI->setUnwindAbort();
+        }
+
         CallInst *CI = dyn_cast<CallInst>(&I);
         if (!CI)
           continue;
 
         // Forward varargs from inlined call site to calls to the
         // ForwardVarArgsTo function, if requested, and to musttail calls.
         if (!VarArgsToForward.empty() &&
             ((ForwardVarArgsTo &&
for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
         //
         // Inlined notail calls should remain notail calls.
         CallInst::TailCallKind ChildTCK = CI->getTailCallKind();
         if (ChildTCK != CallInst::TCK_NoTail)
           ChildTCK = std::min(CallSiteTailKind, ChildTCK);
         CI->setTailCallKind(ChildTCK);
         InlinedMustTailCalls |= CI->isMustTailCall();
 
-        // Call sites inlined through a 'nounwind' call site should be
-        // 'nounwind' as well. However, avoid marking call sites explicitly
-        // where possible. This helps expose more opportunities for CSE after
-        // inlining, commonly when the callee is an intrinsic.
-        if (MarkNoUnwind && !CI->doesNotThrow())
+        // Call sites inlined through a 'nounwind' call should be marked
+        // 'nounwind', unless the inner call was unwindabort (in that case, the
+        // fact that the outer fn can't throw does _not_ imply the inner
+        // function can't throw!)
+        if (MarkNoUnwind && !CI->isUnwindAbort() && !CI->doesNotThrow())
           CI->setDoesNotThrow();
+
+        // Calls inlined through an 'unwindabort' call site should be marked
+        // 'unwindabort'.
+        if (MarkUnwindAbort)
+          CI->setUnwindAbort();
       }
     }
   }
 
   // Leave lifetime markers for the static alloca's, scoping them to the
   // function we just inlined.
   // We need to insert lifetime intrinsics even at O0 to avoid invalid
   // access caused by multithreaded coroutines. The check

llvm/lib/Transforms/Utils/Local.cpp

do {
     Changed |= ConstantFoldTerminator(BB, true, nullptr, DTU);
     for (BasicBlock *Successor : successors(BB))
       if (Reachable.insert(Successor).second)
         Worklist.push_back(Successor);
   } while (!Worklist.empty());
   return Changed;
 }
 
-Instruction *llvm::removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU) {
+void llvm::removeUnwindEdge(BasicBlock *BB, RemoveUnwindEdgeMode Mode,
+                            DomTreeUpdater *DTU) {
   Instruction *TI = BB->getTerminator();
 
-  if (auto *II = dyn_cast<InvokeInst>(TI))
-    return changeToCall(II, DTU);
+  if (auto *II = dyn_cast<InvokeInst>(TI)) {
+    CallInst *CI = changeToCall(II, DTU);
+    if (Mode == RemoveUnwindEdgeMode::Unwindabort)
+      CI->setUnwindAbort(true);
+    if (Mode == RemoveUnwindEdgeMode::Nounwind)
+      CI->setDoesNotThrow();
+    return;
+  }
 
   Instruction *NewTI;
   BasicBlock *UnwindDest;
 
   if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
+    // TODO: With Mode==Unwindabort, we should delete entire cleanup funclet, by
+    // recursively deleting unwind edges _to_ this cleanup.
+    //
+    // TODO: With Mode==Nounwind, we should replace the cleanupret with
+    // 'unreachable'.
     NewTI = CleanupReturnInst::Create(CRI->getCleanupPad(), nullptr, CRI);
     UnwindDest = CRI->getUnwindDest();
   } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
     auto *NewCatchSwitch = CatchSwitchInst::Create(
         CatchSwitch->getParentPad(), nullptr, CatchSwitch->getNumHandlers(),
         CatchSwitch->getName(), CatchSwitch);
     for (BasicBlock *PadBB : CatchSwitch->handlers())
       NewCatchSwitch->addHandler(PadBB);
 
+    if (Mode == RemoveUnwindEdgeMode::Unwindabort) {
+      NewCatchSwitch->setUnwindAbort(true);
+    } else if (Mode == RemoveUnwindEdgeMode::Nounwind) {
+      // TODO: Currently we cannot annotate a catchswitch that cannot unwind, as
+      // it doesn't have a 'nounwind' attribute. Thus, it gets marked 'unwind to
+      // parent instead, and we lose the knowledge that it should be nounwind.
+    }
     NewTI = NewCatchSwitch;
     UnwindDest = CatchSwitch->getUnwindDest();
   } else {
     llvm_unreachable("Could not find unwind successor");
   }
 
   NewTI->takeName(TI);
   NewTI->setDebugLoc(TI->getDebugLoc());
   UnwindDest->removePredecessor(BB);
   TI->replaceAllUsesWith(NewTI);
   TI->eraseFromParent();
   if (DTU)
     DTU->applyUpdates({{DominatorTree::Delete, BB, UnwindDest}});
-  return NewTI;
 }
 
 /// removeUnreachableBlocks - Remove blocks that are not reachable, even
 /// if they are in a dead cycle.  Return true if a change was made, false
 /// otherwise.
 bool llvm::removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU,
                                    MemorySSAUpdater *MSSAU) {
   SmallPtrSet<BasicBlock *, 16> Reachable;

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

for (auto *TrivialBB : TrivialUnwindBlocks) {
     // Blocks that will be simplified should be removed from the phi node.
     // Note there could be multiple edges to the resume block, and we need
     // to remove them all.
     while (PhiLPInst->getBasicBlockIndex(TrivialBB) != -1)
       BB->removePredecessor(TrivialBB, true);
 
     for (BasicBlock *Pred :
          llvm::make_early_inc_range(predecessors(TrivialBB))) {
-      removeUnwindEdge(Pred, DTU);
+      removeUnwindEdge(Pred,
+                       RI->isUnwindAbort() ? RemoveUnwindEdgeMode::Unwindabort
+                                           : RemoveUnwindEdgeMode::Normal,
+                       DTU);
       ++NumInvokes;
     }
 
     // In each SimplifyCFG run, only the current processed block can be erased.
     // Otherwise, it will break the iteration of SimplifyCFG pass. So instead
     // of erasing TrivialBB, we only remove the branch to the common resume
     // block so that we can later erase the resume block since it has no
     // predecessors.
bool SimplifyCFGOpt::simplifySingleResume(ResumeInst *RI) {
 
   // Check that there are no other instructions except for debug intrinsics.
   if (!isCleanupBlockEmpty(
           make_range<Instruction *>(LPInst->getNextNode(), RI)))
     return false;
 
   // Turn all invokes that unwind here into calls and delete the basic block.
   for (BasicBlock *Pred : llvm::make_early_inc_range(predecessors(BB))) {
-    removeUnwindEdge(Pred, DTU);
+    removeUnwindEdge(Pred,
+                     RI->isUnwindAbort() ? RemoveUnwindEdgeMode::Unwindabort
+                                         : RemoveUnwindEdgeMode::Normal,
+                     DTU);
     ++NumInvokes;
   }
 
   // The landingpad is now unreachable.  Zap it.
   DeleteDeadBlock(BB, DTU);
   return true;
 }
 
if (UnwindDest) {
     }
   }
 
   std::vector<DominatorTree::UpdateType> Updates;
 
   // We use make_early_inc_range here because we will remove all predecessors.
   for (BasicBlock *PredBB : llvm::make_early_inc_range(predecessors(BB))) {
     if (UnwindDest == nullptr) {
+      // if cleanupret was previously unwinding to caller, remove the unwind
+      // edge for the predecessor, such that it will unwind to caller directly.
       if (DTU) {
         DTU->applyUpdates(Updates);
         Updates.clear();
       }
-      removeUnwindEdge(PredBB, DTU);
+      removeUnwindEdge(PredBB, RemoveUnwindEdgeMode::Normal, DTU);
       ++NumInvokes;
     } else {
+      // Otherwise, propagate the original unwind-destination into the
+      // predecessor.
       BB->removePredecessor(PredBB);
       Instruction *TI = PredBB->getTerminator();
       TI->replaceUsesOfWith(BB, UnwindDest);
       if (DTU) {
         Updates.push_back({DominatorTree::Insert, PredBB, UnwindDest});
         Updates.push_back({DominatorTree::Delete, PredBB, BB});
       }
     }
if (auto *BI = dyn_cast<BranchInst>(TI)) {
       if (DTU && SI->getDefaultDest() != BB)
         Updates.push_back({DominatorTree::Delete, Predecessor, BB});
     } else if (auto *II = dyn_cast<InvokeInst>(TI)) {
       if (II->getUnwindDest() == BB) {
         if (DTU) {
           DTU->applyUpdates(Updates);
           Updates.clear();
         }
-        auto *CI = cast<CallInst>(removeUnwindEdge(TI->getParent(), DTU));
-        if (!CI->doesNotThrow())
-          CI->setDoesNotThrow();
+        removeUnwindEdge(TI->getParent(), RemoveUnwindEdgeMode::Nounwind, DTU);
         Changed = true;
       }
     } else if (auto *CSI = dyn_cast<CatchSwitchInst>(TI)) {
       if (CSI->getUnwindDest() == BB) {
         if (DTU) {
           DTU->applyUpdates(Updates);
           Updates.clear();
         }
-        removeUnwindEdge(TI->getParent(), DTU);
+        removeUnwindEdge(TI->getParent(), RemoveUnwindEdgeMode::Nounwind, DTU);
         Changed = true;
         continue;
       }
 
       for (CatchSwitchInst::handler_iterator I = CSI->handler_begin(),
                                              E = CSI->handler_end();
            I != E; ++I) {
         if (*I == BB) {
           CSI->removeHandler(I);
           --I;
           --E;
           Changed = true;
         }
       }
       if (DTU)
         Updates.push_back({DominatorTree::Delete, Predecessor, BB});
       if (CSI->getNumHandlers() == 0) {
+        // No switch clauses left: the catchswitch will always unwind.
         if (CSI->hasUnwindDest()) {
           // Redirect all predecessors of the block containing CatchSwitchInst
           // to instead branch to the CatchSwitchInst's unwind destination.
           if (DTU) {
             for (auto *PredecessorOfPredecessor : predecessors(Predecessor)) {
               Updates.push_back({DominatorTree::Insert,
                                  PredecessorOfPredecessor,
                                  CSI->getUnwindDest()});
               Updates.push_back({DominatorTree::Delete,
                                  PredecessorOfPredecessor, Predecessor});
             }
           }
           Predecessor->replaceAllUsesWith(CSI->getUnwindDest());
         } else {
-          // Rewrite all preds to unwind to caller (or from invoke to call).
+          // Unwind destination is not a block: rewrite all preds to the
+          // appropriate target ('unwind to caller' or unwindabort). This will
+          // e.g. rewrite 'invoke' to 'call'.
           if (DTU) {
             DTU->applyUpdates(Updates);
             Updates.clear();
           }
           SmallVector<BasicBlock *, 8> EHPreds(predecessors(Predecessor));
           for (BasicBlock *EHPred : EHPreds)
-            removeUnwindEdge(EHPred, DTU);
+            removeUnwindEdge(EHPred,
+                             CSI->isUnwindAbort()
+                                 ? RemoveUnwindEdgeMode::Unwindabort
+                                 : RemoveUnwindEdgeMode::Normal,
+                             DTU);
         }
         // The catchswitch is no longer reachable.
         new UnreachableInst(CSI->getContext(), CSI);
         CSI->eraseFromParent();
         Changed = true;
       }
     } else if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
       (void)CRI;

llvm/test/Instrumentation/ThreadSanitizer/eh.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=tsan -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-EXC
 ; RUN: opt < %s -passes=tsan -S -tsan-handle-cxx-exceptions=0 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOEXC
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 declare void @can_throw()
 declare void @cannot_throw() nounwind
 
 define i32 @func1() sanitize_thread {
-  call void @can_throw()
-  ret i32 0
-  ; CHECK-EXC: define i32 @func1()
-  ; CHECK-EXC:   call void @__tsan_func_entry
-  ; CHECK-EXC:   invoke void @can_throw()
-  ; CHECK-EXC: .noexc:
-  ; CHECK-EXC:   call void @__tsan_func_exit()
-  ; CHECK-EXC:   ret i32 0
-  ; CHECK-EXC: tsan_cleanup:
-  ; CHECK-EXC:   call void @__tsan_func_exit()
-  ; CHECK-EXC:   resume
-  ; CHECK-NOEXC: define i32 @func1()
-  ; CHECK-NOEXC: call void @__tsan_func_entry
-  ; CHECK-NOEXC: call void @can_throw()
-  ; CHECK-NOEXC: call void @__tsan_func_exit()
-  ; CHECK-NOEXC: ret i32 0
+; CHECK-EXC-LABEL: @func1(
+; CHECK-EXC-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-EXC-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-EXC-NEXT:    invoke void @can_throw()
+; CHECK-EXC-NEXT:    to label [[DOTNOEXC:%.*]] unwind label [[TSAN_CLEANUP:%.*]]
+; CHECK-EXC:       .noexc:
+; CHECK-EXC-NEXT:    call void @__tsan_func_exit()
+; CHECK-EXC-NEXT:    ret i32 0
+; CHECK-EXC:       tsan_cleanup:
+; CHECK-EXC-NEXT:    [[CLEANUP_LPAD:%.*]] = landingpad { ptr, i32 }
+; CHECK-EXC-NEXT:    cleanup
+; CHECK-EXC-NEXT:    call void @__tsan_func_exit()
+; CHECK-EXC-NEXT:    resume { ptr, i32 } [[CLEANUP_LPAD]]
+;
+; CHECK-NOEXC-LABEL: @func1(
+; CHECK-NOEXC-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NOEXC-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NOEXC-NEXT:    call void @can_throw()
+; CHECK-NOEXC-NEXT:    call void @__tsan_func_exit()
+; CHECK-NOEXC-NEXT:    ret i32 0
+;
+  call void @can_throw()
+  ret i32 0
 }
 
 define i32 @func2() sanitize_thread {
+; CHECK-LABEL: @func2(
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NEXT:    call void @cannot_throw()
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret i32 0
+;
   call void @cannot_throw()
   ret i32 0
-  ; CHECK: define i32 @func2()
-  ; CHECK: call void @__tsan_func_entry
-  ; CHECK: call void @cannot_throw()
-  ; CHECK: call void @__tsan_func_exit()
-  ; CHECK: ret i32 0
 }
 
 define i32 @func3(ptr %p) sanitize_thread {
+; CHECK-LABEL: @func3(
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NEXT:    call void @__tsan_read4(ptr [[P:%.*]])
+; CHECK-NEXT:    [[A:%.*]] = load i32, ptr [[P]], align 4
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret i32 [[A]]
+;
   %a = load i32, ptr %p
   ret i32 %a
-  ; CHECK: define i32 @func3(ptr %p)
-  ; CHECK: call void @__tsan_func_entry
-  ; CHECK: call void @__tsan_read4
-  ; CHECK: %a = load i32, ptr %p
-  ; CHECK: call void @__tsan_func_exit()
-  ; CHECK: ret i32 %a
 }
 
 define i32 @func4() sanitize_thread nounwind {
+; CHECK-LABEL: @func4(
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NEXT:    call void @can_throw()
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret i32 0
+;
   call void @can_throw()
   ret i32 0
-  ; CHECK: define i32 @func4()
-  ; CHECK: call void @__tsan_func_entry
-  ; CHECK: call void @can_throw()
-  ; CHECK: call void @__tsan_func_exit()
-  ; CHECK: ret i32 0
+}
+
+define i32 @func5() sanitize_thread personality ptr @__gxx_personality_v0 {
+; CHECK-LABEL: @func5(
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NEXT:    call unwindabort void @can_throw()
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret i32 0
+;
+  call unwindabort void @can_throw()
+  ret i32 0
+}
+
+declare i1 @maybe_raise_exception() uwtable noinline willreturn
+declare i32 @__gxx_personality_v0(...)
+
+define void @invoke_test() sanitize_thread personality ptr @__gxx_personality_v0  {
+; CHECK-LABEL: @invoke_test(
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = invoke i1 @maybe_raise_exception()
+; CHECK-NEXT:    to label [[N:%.*]] unwind label [[F:%.*]]
+; CHECK:       N:
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret void
+; CHECK:       F:
+; CHECK-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT:    catch ptr null
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret void
+;
+  invoke i1 @maybe_raise_exception()
+  to label %N unwind label %F
+  N:
+  ret void
+  F:
+  %val = landingpad { ptr, i32 }
+  catch ptr null
+  ret void
+}
+
+define void @invoke_test2() sanitize_thread personality ptr @__gxx_personality_v0  {
+; CHECK-LABEL: @invoke_test2(
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = invoke i1 @maybe_raise_exception()
+; CHECK-NEXT:    to label [[N:%.*]] unwind label [[F:%.*]]
+; CHECK:       N:
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret void
+; CHECK:       F:
+; CHECK-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT:    cleanup
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    resume { ptr, i32 } [[VAL]]
+;
+  invoke i1 @maybe_raise_exception()
+  to label %N unwind label %F
+  N:
+  ret void
+  F:
+  %val = landingpad { ptr, i32 } cleanup
+
+  resume {ptr, i32 } %val
+}
+
+define void @invoke_test3() sanitize_thread personality ptr @__gxx_personality_v0 {
+; CHECK-LABEL: @invoke_test3(
+; CHECK-NEXT:    [[TMP1:%.*]] = call ptr @llvm.returnaddress(i32 0)
+; CHECK-NEXT:    call void @__tsan_func_entry(ptr [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = invoke i1 @maybe_raise_exception()
+; CHECK-NEXT:    to label [[N:%.*]] unwind label [[F:%.*]]
+; CHECK:       N:
+; CHECK-NEXT:    call void @__tsan_func_exit()
+; CHECK-NEXT:    ret void
+; CHECK:       F:
+; CHECK-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT:    cleanup
+; CHECK-NEXT:    resume unwindabort { ptr, i32 } [[VAL]]
+;
+  invoke i1 @maybe_raise_exception()
+  to label %N unwind label %F
+  N:
+  ret void
+  F:
+  %val = landingpad { ptr, i32 } cleanup
+
+  resume unwindabort {ptr, i32 } %val
 }

llvm/test/Transforms/Attributor/nounwind.ll

 ; CGSCC-LABEL: define {{[^@]+}}@catch_thing_user() {
 ; CGSCC-NEXT:    [[CATCH_THING_CALL:%.*]] = call noundef i32 @catch_thing()
 ; CGSCC-NEXT:    ret i32 [[CATCH_THING_CALL]]
 ;
   %catch_thing_call = call i32 @catch_thing()
   ret i32 %catch_thing_call
 }
 
+; TEST 7: test that it's possible to deduce nounwind even when the
+; function contains an invoke to a throwing function. Unlike the
+; above test, the only potentially-unwinding calls are through
+; 'invoke'.
+define i32 @test_invoke_nounwind(i1 zeroext %val) personality ptr @__gxx_personality_v0 {
+; TUNIT: Function Attrs: noreturn nounwind
+; TUNIT-LABEL: define {{[^@]+}}@test_invoke_nounwind
+; TUNIT-SAME: (i1 zeroext [[VAL:%.*]]) #[[ATTR2:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[CALL:%.*]] = invoke noundef i32 @maybe_throw(i1 [[VAL]])
+; TUNIT-NEXT:    to label [[TRY_CONT:%.*]] unwind label [[LPAD:%.*]]
+; TUNIT:       lpad:
+; TUNIT-NEXT:    [[TMP0:%.*]] = landingpad { ptr, i32 }
+; TUNIT-NEXT:    catch ptr null
+; TUNIT-NEXT:    [[TMP1:%.*]] = extractvalue { ptr, i32 } [[TMP0]], 0
+; TUNIT-NEXT:    [[TMP2:%.*]] = tail call ptr @__cxa_begin_catch(ptr [[TMP1]]) #[[ATTR3:[0-9]+]]
+; TUNIT-NEXT:    tail call void @abort() #[[ATTR2]]
+; TUNIT-NEXT:    unreachable
+; TUNIT:       try.cont:
+; TUNIT-NEXT:    unreachable
+;
+; CGSCC: Function Attrs: noreturn nounwind
+; CGSCC-LABEL: define {{[^@]+}}@test_invoke_nounwind
+; CGSCC-SAME: (i1 noundef zeroext [[VAL:%.*]]) #[[ATTR1:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[CALL:%.*]] = invoke noundef i32 @maybe_throw(i1 noundef [[VAL]])
+; CGSCC-NEXT:    to label [[TRY_CONT:%.*]] unwind label [[LPAD:%.*]]
+; CGSCC:       lpad:
+; CGSCC-NEXT:    [[TMP0:%.*]] = landingpad { ptr, i32 }
+; CGSCC-NEXT:    catch ptr null
+; CGSCC-NEXT:    [[TMP1:%.*]] = extractvalue { ptr, i32 } [[TMP0]], 0
+; CGSCC-NEXT:    [[TMP2:%.*]] = tail call ptr @__cxa_begin_catch(ptr [[TMP1]]) #[[ATTR2:[0-9]+]]
+; CGSCC-NEXT:    tail call void @abort() #[[ATTR1]]
+; CGSCC-NEXT:    unreachable
+; CGSCC:       try.cont:
+; CGSCC-NEXT:    unreachable
+;
+entry:
+  %call = invoke noundef i32 @maybe_throw(i1 %val)
+  to label %try.cont unwind label %lpad
+
+lpad:                                             ; preds = %entry
+  %0 = landingpad { ptr, i32 }
+  catch ptr null
+  %1 = extractvalue { ptr, i32 } %0, 0
+  %2 = tail call ptr @__cxa_begin_catch(ptr %1) nounwind
+  tail call void @abort() noreturn nounwind
+  unreachable
+
+try.cont:                                         ; preds = %entry
+  unreachable
+}
+
+; TEST 8: test that a function body with 'call unwindabort' can be
+; deduced as nounwind.
+define i32 @test_unwindabort(i1 zeroext %val) personality ptr @__gxx_personality_v0 {
+; TUNIT: Function Attrs: nounwind
+; TUNIT-LABEL: define {{[^@]+}}@test_unwindabort
+; TUNIT-SAME: (i1 zeroext [[VAL:%.*]]) #[[ATTR3]] personality ptr @__gxx_personality_v0 {
+; TUNIT-NEXT:    [[CALL:%.*]] = call unwindabort i32 @maybe_throw(i1 [[VAL]])
+; TUNIT-NEXT:    ret i32 -1
+;
+; CGSCC: Function Attrs: nounwind
+; CGSCC-LABEL: define {{[^@]+}}@test_unwindabort
+; CGSCC-SAME: (i1 noundef zeroext [[VAL:%.*]]) #[[ATTR2]] personality ptr @__gxx_personality_v0 {
+; CGSCC-NEXT:    [[CALL:%.*]] = call unwindabort noundef i32 @maybe_throw(i1 noundef [[VAL]])
+; CGSCC-NEXT:    ret i32 [[CALL]]
+;
+  %call = call unwindabort i32 @maybe_throw(i1 %val)
+  ret i32 %call
+}
+
+declare void @abort() local_unnamed_addr noreturn nounwind
 
 declare i32 @__gxx_personality_v0(...)
 
 declare ptr @__cxa_begin_catch(ptr)
 
 declare void @__cxa_end_catch()
 ;.
 ; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) }
 ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) }
+; TUNIT: attributes #[[ATTR2]] = { noreturn nounwind }
+; TUNIT: attributes #[[ATTR3]] = { nounwind }
 ;.
 ; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) }
+; CGSCC: attributes #[[ATTR1]] = { noreturn nounwind }
+; CGSCC: attributes #[[ATTR2]] = { nounwind }
 ;.

llvm/test/Transforms/Attributor/willreturn.ll

;
   N:
   ret void
   F:
   %val = landingpad { i8*, i32 }
   catch i8* null
   ret void
 }
 
+; Positive test: calling a willreturn function that may unwind is OK:
+; it'll either unwind or return.
+define void @call_unwind_test() noinline uwtable {
+; TUNIT: Function Attrs: noinline willreturn uwtable
+; TUNIT-LABEL: define {{[^@]+}}@call_unwind_test
+; TUNIT-SAME: () #[[ATTR11:[0-9]+]] {
+; TUNIT-NEXT:    [[TMP1:%.*]] = call i1 @maybe_raise_exception() #[[ATTR27]]
+; TUNIT-NEXT:    ret void
+;
+; CGSCC: Function Attrs: noinline willreturn uwtable
+; CGSCC-LABEL: define {{[^@]+}}@call_unwind_test
+; CGSCC-SAME: () #[[ATTR11:[0-9]+]] {
+; CGSCC-NEXT:    [[TMP1:%.*]] = call i1 @maybe_raise_exception() #[[ATTR28]]
+; CGSCC-NEXT:    ret void
+;
+  call i1 @maybe_raise_exception()
+  ret void
+}
+
+; Negative test: a 'call unwindabort' is _not_ OK: it may abort.
+define void @callabort_unwind_test() #0 personality i32 (...)* @__gxx_personality_v0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@callabort_unwind_test
+; CHECK-SAME: () #[[ATTR7]] personality i32 (...)* @__gxx_personality_v0 {
+; CHECK-NEXT:    [[TMP1:%.*]] = call unwindabort i1 @maybe_raise_exception()
+; CHECK-NEXT:    ret void
+;
+  call unwindabort i1 @maybe_raise_exception()
+  ret void
+}
+
 declare i32 @__gxx_personality_v0(...)
 
 
 ; TEST 11 (positive case)
 ; constant trip count
 ; int loop_constant_trip_count(int*p){
 ;    int ans = 0;
 ;    for(int i = 0;i<10;i++){

 ; CGSCC-SAME: () #[[ATTR26]] {
 ; CGSCC-NEXT:    call void @willreturn_mustprogress_callee_2() #[[ATTR28]]
 ; CGSCC-NEXT:    ret void
 ;
   call void @willreturn_mustprogress_callee_2()
   ret void
 }
 
+
 attributes #0 = { nounwind uwtable noinline }
 attributes #1 = { uwtable noinline }
 ;.
 ; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
 ; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
 ; TUNIT: attributes #[[ATTR2]] = { nofree noinline norecurse nosync nounwind memory(none) uwtable }
 ; TUNIT: attributes #[[ATTR3:[0-9]+]] = { nofree nosync nounwind willreturn }
 ; TUNIT: attributes #[[ATTR4]] = { nofree noinline nosync nounwind uwtable }
 ; TUNIT: attributes #[[ATTR5]] = { noreturn }
 ; TUNIT: attributes #[[ATTR6]] = { noinline noreturn nounwind uwtable }
 ; TUNIT: attributes #[[ATTR7]] = { noinline nounwind uwtable }
 ; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
 ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { norecurse willreturn }
 ; TUNIT: attributes #[[ATTR10]] = { noinline nounwind willreturn uwtable }
-; TUNIT: attributes #[[ATTR11:[0-9]+]] = { noinline willreturn uwtable }
+; TUNIT: attributes #[[ATTR11]] = { noinline willreturn uwtable }
 ; TUNIT: attributes #[[ATTR12]] = { nounwind willreturn }
 ; TUNIT: attributes #[[ATTR13]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable }
 ; TUNIT: attributes #[[ATTR14]] = { nofree noinline norecurse nosync nounwind memory(argmem: read) uwtable }
 ; TUNIT: attributes #[[ATTR15]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable }
 ; TUNIT: attributes #[[ATTR16:[0-9]+]] = { noreturn nounwind }
 ; TUNIT: attributes #[[ATTR17]] = { nofree norecurse nosync nounwind memory(none) }
 ; TUNIT: attributes #[[ATTR18]] = { nofree norecurse nosync nounwind willreturn memory(none) }
 ; TUNIT: attributes #[[ATTR19:[0-9]+]] = { memory(read) }

 ; CGSCC: attributes #[[ATTR3:[0-9]+]] = { nofree nosync nounwind willreturn }
 ; CGSCC: attributes #[[ATTR4]] = { nofree noinline nosync nounwind uwtable }
 ; CGSCC: attributes #[[ATTR5]] = { noreturn }
 ; CGSCC: attributes #[[ATTR6]] = { noinline noreturn nounwind uwtable }
 ; CGSCC: attributes #[[ATTR7]] = { noinline nounwind uwtable }
 ; CGSCC: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
 ; CGSCC: attributes #[[ATTR9:[0-9]+]] = { norecurse willreturn }
 ; CGSCC: attributes #[[ATTR10]] = { noinline nounwind willreturn uwtable }
-; CGSCC: attributes #[[ATTR11:[0-9]+]] = { noinline willreturn uwtable }
+; CGSCC: attributes #[[ATTR11]] = { noinline willreturn uwtable }
 ; CGSCC: attributes #[[ATTR12]] = { nounwind willreturn }
 ; CGSCC: attributes #[[ATTR13]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable }
 ; CGSCC: attributes #[[ATTR14]] = { nofree noinline norecurse nosync nounwind memory(argmem: read) uwtable }
 ; CGSCC: attributes #[[ATTR15]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable }
 ; CGSCC: attributes #[[ATTR16:[0-9]+]] = { noreturn nounwind }
 ; CGSCC: attributes #[[ATTR17]] = { nofree norecurse nosync nounwind memory(none) }
 ; CGSCC: attributes #[[ATTR18]] = { nofree norecurse nosync nounwind willreturn memory(none) }
 ; CGSCC: attributes #[[ATTR19]] = { nofree nosync nounwind memory(none) }

llvm/test/Transforms/FunctionAttrs/nounwind.ll

2:                                                ; preds = %1
   unreachable
 
 3:                                                ; preds = %1
   ret i32 -1
 }
 
 declare void @__cxa_rethrow()
 
-; TEST 6 - catch
+; TEST 6 - catch.
+;
+; In this test, it is not possible to deduce nounwind for
+; "catch_thing", because the call to @__cxa_end_catch is not marked
+; nounwind. TODO: _could_ it be marked nounwind?
+
 ; int catch_thing() {
 ;   try {
 ;       int a = doThing(true);
 ;   }
 ;   catch(...) { return -1; }
 ;   return 1;
 ; }
 

 ; CHECK-LABEL: define {{[^@]+}}@catch_thing_user() {
 ; CHECK-NEXT:    [[CATCH_THING_CALL:%.*]] = call i32 @catch_thing()
 ; CHECK-NEXT:    ret i32 [[CATCH_THING_CALL]]
 ;
   %catch_thing_call = call i32 @catch_thing()
   ret i32 %catch_thing_call
 }
 
+; TEST 7: test that it's possible to deduce nounwind even when the
+; function contains an invoke to a throwing function. Unlike the
+; above test, the only potentially-unwinding calls are through
+; 'invoke'.
+define i32 @test_invoke_nounwind(i1 zeroext %val) personality ptr @__gxx_personality_v0 {
+; CHECK: Function Attrs: noreturn nounwind
+; CHECK-LABEL: define {{[^@]+}}@test_invoke_nounwind
+; CHECK-SAME: (i1 zeroext [[VAL:%.*]]) #[[ATTR2:[0-9]+]] personality ptr @__gxx_personality_v0 {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CALL:%.*]] = invoke noundef i32 @maybe_throw(i1 [[VAL]])
+; CHECK-NEXT:    to label [[TRY_CONT:%.*]] unwind label [[LPAD:%.*]]
+; CHECK:       lpad:
+; CHECK-NEXT:    [[TMP0:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT:    catch ptr null
+; CHECK-NEXT:    [[TMP1:%.*]] = extractvalue { ptr, i32 } [[TMP0]], 0
+; CHECK-NEXT:    [[TMP2:%.*]] = tail call ptr @__cxa_begin_catch(ptr [[TMP1]]) #[[ATTR3:[0-9]+]]
+; CHECK-NEXT:    tail call void @abort() #[[ATTR2]]
+; CHECK-NEXT:    unreachable
+; CHECK:       try.cont:
+; CHECK-NEXT:    unreachable
+;
+entry:
+  %call = invoke noundef i32 @maybe_throw(i1 %val)
+  to label %try.cont unwind label %lpad
+
+lpad:                                             ; preds = %entry
+  %0 = landingpad { ptr, i32 }
+  catch ptr null
+  %1 = extractvalue { ptr, i32 } %0, 0
+  %2 = tail call ptr @__cxa_begin_catch(ptr %1) nounwind
+  tail call void @abort() noreturn nounwind
+  unreachable
+
+try.cont:                                         ; preds = %entry
+  unreachable
+}
+
+; TEST 8: test that a function body with 'call unwindabort' can be
+; deduced as nounwind.
+define i32 @test_unwindabort(i1 zeroext %val) personality ptr @__gxx_personality_v0 {
+; CHECK: Function Attrs: nounwind
+; CHECK-LABEL: define {{[^@]+}}@test_unwindabort
+; CHECK-SAME: (i1 zeroext [[VAL:%.*]]) #[[ATTR3]] personality ptr @__gxx_personality_v0 {
+; CHECK-NEXT:    [[CALL:%.*]] = call unwindabort i32 @maybe_throw(i1 [[VAL]])
+; CHECK-NEXT:    ret i32 [[CALL]]
+;
+  %call = call unwindabort i32 @maybe_throw(i1 %val)
+  ret i32 %call
+}
+
+declare void @abort() local_unnamed_addr noreturn nounwind
+
 
 declare i32 @__gxx_personality_v0(...)
 
 declare ptr @__cxa_begin_catch(ptr)
 
 declare void @__cxa_end_catch()

llvm/test/Transforms/FunctionAttrs/willreturn.ll

 ; CHECK-NEXT:    ret i32 [[TMP2]]
 ;
   %2 = mul nsw i32 %0, %0
   ret i32 %2
 }
 
 declare i64 @fn_noread() readnone
 declare void @fn_willreturn() willreturn
+
+
+declare i1 @maybe_raise_exception() uwtable noinline willreturn
+
+; Positive test: an invoke does not block willreturn
+define void @invoke_test() personality ptr @__gxx_personality_v0 {
+; CHECK: Function Attrs: mustprogress nounwind willreturn
+; CHECK-LABEL: @invoke_test(
+; CHECK-NEXT:    [[TMP1:%.*]] = invoke i1 @maybe_raise_exception()
+; CHECK-NEXT:    to label [[N:%.*]] unwind label [[F:%.*]]
+; CHECK:       N:
+; CHECK-NEXT:    ret void
+; CHECK:       F:
+; CHECK-NEXT:    [[VAL:%.*]] = landingpad { ptr, i32 }
+; CHECK-NEXT:    catch ptr null
+; CHECK-NEXT:    ret void
+;
+  invoke i1 @maybe_raise_exception()
+  to label %N unwind label %F
+  N:
+  ret void
+  F:
+  %val = landingpad { ptr, i32 }
+  catch ptr null
+  ret void
+}
+
+; Positive test: calling a willreturn function that may unwind is OK, too.
+define void @call_unwind_test() noinline uwtable {
+; CHECK: Function Attrs: mustprogress noinline willreturn uwtable
+; CHECK-LABEL: @call_unwind_test(
+; CHECK-NEXT:    [[TMP1:%.*]] = call i1 @maybe_raise_exception()
+; CHECK-NEXT:    ret void
+;
+  call i1 @maybe_raise_exception()
+  ret void
+}
+
+; Negative test: a 'call unwindabort' is _not_ OK: it may abort.
+define void @callabort_unwind_test() nounwind uwtable noinline personality ptr @__gxx_personality_v0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: @callabort_unwind_test(
+; CHECK-NEXT:    [[TMP1:%.*]] = call unwindabort i1 @maybe_raise_exception()
+; CHECK-NEXT:    ret void
+;
+  call unwindabort i1 @maybe_raise_exception()
+  ret void
+}

llvm/test/Transforms/Inline/inline-unwindabort.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
+; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
+
+;; Ensure that inlining propagates unwindabort as expected:
+;;
+;; Unwindabort on a callsite attaches to all calls inlined through it.
+;;
+;; A nounwind callsite propagates nounwind to calls inlined through
+;; it, except that an unwindabort inner call cannot be deduced to be
+;; nounwind, as it's unwind doesn't propagate out.
+declare void @extern()
+declare void @extern_nounwind() nounwind
+declare i32 @__gxx_personality_v0(...)
+
+define internal void @inlined_callee() personality ptr @__gxx_personality_v0 {
+entry:
+  call void @extern()
+  call void @extern_nounwind() nounwind
+  call unwindabort void @extern()
+  call unwindabort void @extern_nounwind() nounwind
+  ret void
+}
+
+define void @caller() {
+;
+; CHECK-LABEL: @caller(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @extern()
+; CHECK-NEXT:    call void @extern_nounwind() #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    call unwindabort void @extern()
+; CHECK-NEXT:    call unwindabort void @extern_nounwind() #[[ATTR0]]
+; CHECK-NEXT:    ret void
+;
+entry:
+  call void @inlined_callee()
+  ret void
+}
+
+define void @nounwind_caller() {
+;
+; CHECK-LABEL: @nounwind_caller(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call void @extern() #[[ATTR0]]
+; CHECK-NEXT:    call void @extern_nounwind() #[[ATTR0]]
+; CHECK-NEXT:    call unwindabort void @extern()
+; CHECK-NEXT:    call unwindabort void @extern_nounwind() #[[ATTR0]]
+; CHECK-NEXT:    ret void
+;
+entry:
+  call void @inlined_callee() nounwind
+  ret void
+}
+
+define void @unwindabort_caller() personality ptr @__gxx_personality_v0 {
+;
+; CHECK-LABEL: @unwindabort_caller(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call unwindabort void @extern()
+; CHECK-NEXT:    call unwindabort void @extern_nounwind() #[[ATTR0]]
+; CHECK-NEXT:    call unwindabort void @extern()
+; CHECK-NEXT:    call unwindabort void @extern_nounwind() #[[ATTR0]]
+; CHECK-NEXT:    ret void
+;
+entry:
+  call unwindabort void @inlined_callee()
+  ret void
+}
+
+define void @unwindabort_nounwind_caller() personality ptr @__gxx_personality_v0 {
+;
+; CHECK-LABEL: @unwindabort_nounwind_caller(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    call unwindabort void @extern() #[[ATTR0]]
+; CHECK-NEXT:    call unwindabort void @extern_nounwind() #[[ATTR0]]
+; CHECK-NEXT:    call unwindabort void @extern()
+; CHECK-NEXT:    call unwindabort void @extern_nounwind() #[[ATTR0]]
+; CHECK-NEXT:    ret void
+;
+entry:
+  call unwindabort void @inlined_callee() nounwind
+  ret void
+}
+
+;.
+; CHECK: attributes #[[ATTR0]] = { nounwind }
+;.

llvm/test/Transforms/InstCombine/nothrow.ll

-; RUN: opt < %s -passes=instcombine -S | not grep call
-; rdar://6880732
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes --check-globals
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 declare double @t1(i32) readonly willreturn
 
+;; The call is marked nounwind, even though callee is not nounwind, as
+;; it would be UB to unwind from it through this nounwind
+;; function. (And thus, the call can be removed due to being unused
+;; and free of side effects.)
 define void @t2() nounwind {
-  call double @t1(i32 42)  ;; dead call even though callee is not nothrow.
+; CHECK: Function Attrs: nounwind
+; CHECK-LABEL: @t2(
+; CHECK-NEXT:    ret void
+;
+  call double @t1(i32 42)
   ret void
 }
+
+;; If a `call unwindabort` is within a nounwind function, that does
+;; NOT mean the call itself must be nounwind. Due to the
+;; 'unwindabort', the call will not continue to unwind.
+define void @t3() nounwind personality ptr @__gxx_personality_v0 {
+; CHECK: Function Attrs: nounwind
+; CHECK-LABEL: @t3(
+; CHECK-NEXT:    [[TMP1:%.*]] = call unwindabort double @t1(i32 42)
+; CHECK-NEXT:    ret void
+;
+  call unwindabort double @t1(i32 42)
+  ret void
+}
+
+declare i32 @__gxx_personality_v0(...)
+
+;.
+; CHECK: attributes #[[ATTR0:[0-9]+]] = { willreturn memory(read) }
+; CHECK: attributes #[[ATTR1:[0-9]+]] = { nounwind }
+;.

llvm/test/Transforms/InstCombine/unwindabort.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+declare void @nothrow() nounwind
+declare i32 @__gxx_personality_v0(...)
+declare i32 @_except_handler3(...)
+
+; Verify that unwindabort is removed when a call is nounwind.
+define void @test() personality ptr @__gxx_personality_v0 {
+; CHECK-LABEL: @test(
+; CHECK-NEXT:    call void @nothrow()
+; CHECK-NEXT:    ret void
+;
+  call unwindabort void @nothrow()
+  ret void
+}
+
+; ...except we can't remove unwindabort of a nounwind function, if the
+; personality handles async exceptions.
+define void @testSEH() personality ptr @_except_handler3 {
+; CHECK-LABEL: @testSEH(
+; CHECK-NEXT:    call unwindabort void @nothrow()
+; CHECK-NEXT:    ret void
+;
+  call unwindabort void @nothrow()
+  ret void
+}
+

llvm/test/Transforms/SimplifyCFG/invoke_unwind.ll

rethrow:
   resume { ptr, i32 } %lp
 
 lpad2:
   %1 = landingpad { ptr, i32 }
   cleanup
   br label %rethrow
 }
 
+
+;; Now test that both simple-resume and common-resume propagate unwindabort properly.
+define i32 @test4() personality ptr @__gxx_personality_v0 {
+; CHECK-LABEL: @test4(
+; CHECK-NEXT:    call unwindabort void @bar()
+; CHECK-NEXT:    ret i32 0
+;
+  invoke void @bar( )
+    to label %1 unwind label %Rethrow
+  ret i32 0
+Rethrow:
+  %exn = landingpad {ptr, i32}
+  cleanup
+  resume unwindabort {ptr, i32} %exn
+}
+
+define i64 @test5(i1 %cond) personality ptr @__gxx_personality_v0 {
+; CHECK-LABEL: @test5(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BR1:%.*]], label [[BR2:%.*]]
+; CHECK:       br1:
+; CHECK-NEXT:    [[CALL1:%.*]] = call unwindabort i64 @dummy1()
+; CHECK-NEXT:    br label [[INVOKE_CONT:%.*]]
+; CHECK:       br2:
+; CHECK-NEXT:    [[CALL2:%.*]] = call unwindabort i64 @dummy2()
+; CHECK-NEXT:    br label [[INVOKE_CONT]]
+; CHECK:       invoke.cont:
+; CHECK-NEXT:    [[C:%.*]] = phi i64 [ [[CALL1]], [[BR1]] ], [ [[CALL2]], [[BR2]] ]
+; CHECK-NEXT:    ret i64 [[C]]
+;
+entry:
+  br i1 %cond, label %br1, label %br2
+
+br1:
+  %call1 = invoke i64 @dummy1()
+  to label %invoke.cont unwind label %lpad1
+
+br2:
+  %call2 = invoke i64 @dummy2()
+  to label %invoke.cont unwind label %lpad2
+
+invoke.cont:
+  %c = phi i64 [%call1, %br1], [%call2, %br2]
+  ret i64 %c
+
+lpad1:
+  %0 = landingpad { ptr, i32 }
+  cleanup
+  br label %rethrow
+
+rethrow:
+  %lp = phi { ptr, i32 } [%0, %lpad1], [%1, %lpad2]
+  resume unwindabort { ptr, i32 } %lp
+
+lpad2:
+  %1 = landingpad { ptr, i32 }
+  cleanup
+  br label %rethrow
+}
+
+
 declare i32 @__gxx_personality_v0(...)
 ;.
 ; CHECK: [[PROF0]] = !{!"branch_weights", i32 371}
 ;.

llvm/test/Verifier/musttail-invalid.ll

; CHECK: musttail call must precede a ret with an optional bitcast
   ret i32 %w
 }
 
 define void @inline_asm() {
 ; CHECK: cannot use musttail call with inline asm
   musttail call void asm "ret", ""()
   ret void
 }
+
+declare i32 @testfn()
+declare void @person()
+define i32 @unwindabort() personality ptr @person {
+; CHECK: cannot use musttail with unwindabort
+  %v = musttail call unwindabort i32 @testfn()
+  ret i32 %v
+}