diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -873,6 +873,11 @@
   returning uninitialized variables from functions is more aggressively
   reported. ``-fno-sanitize-memory-param-retval`` restores the previous
   behavior.
+- A new Undefined Behavior Sanitizer check has been implemented:
+  ``-fsanitize=exception-escape`` (part of ``-fsanitize=undefined``),
+  which catches cases of C++ exceptions trying to unwind
+  out of non-unwindable functions.
+
 
 Core Analysis Improvements
 ==========================
diff --git a/clang/docs/UndefinedBehaviorSanitizer.rst b/clang/docs/UndefinedBehaviorSanitizer.rst
--- a/clang/docs/UndefinedBehaviorSanitizer.rst
+++ b/clang/docs/UndefinedBehaviorSanitizer.rst
@@ -180,6 +180,8 @@
      Incompatible with ``-fno-rtti``. Link must be performed by ``clang++``, not
      ``clang``, to make sure C++-specific parts of the runtime library and C++
      standard libraries are present.
+  -  ``-fsanitize=exception-escape``: A C++ exception unwinding out of an
+     non-unwind function is an undefined behavior. This catches such situations.
 
 You can also use the following check groups:
   -  ``-fsanitize=undefined``: All of the checks listed above other than
diff --git a/clang/include/clang/Basic/Sanitizers.def b/clang/include/clang/Basic/Sanitizers.def
--- a/clang/include/clang/Basic/Sanitizers.def
+++ b/clang/include/clang/Basic/Sanitizers.def
@@ -107,6 +107,7 @@
 SANITIZER("unreachable", Unreachable)
 SANITIZER("vla-bound", VLABound)
 SANITIZER("vptr", Vptr)
+SANITIZER("exception-escape", ExceptionEscape)
 
 // IntegerSanitizer
 SANITIZER("unsigned-integer-overflow", UnsignedIntegerOverflow)
@@ -144,7 +145,7 @@
                     IntegerDivideByZero | NonnullAttribute | Null | ObjectSize |
                     PointerOverflow | Return | ReturnsNonnullAttribute | Shift |
                     SignedIntegerOverflow | Unreachable | VLABound | Function |
-                    Vptr)
+                    Vptr | ExceptionEscape)
 
 // -fsanitize=undefined-trap is an alias for -fsanitize=undefined.
 SANITIZER_GROUP("undefined-trap", UndefinedTrap, Undefined)
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -5399,7 +5399,14 @@
   llvm::CallBase *CI;
   if (!InvokeDest) {
     CI = Builder.CreateCall(IRFuncTy, CalleePtr, IRCallArgs, BundleList);
+    if (EHStack.wouldUnwindBeUB())
+      Attrs = Attrs.addFnAttribute(getLLVMContext(),
+                                   llvm::Attribute::AttrKind::NoUnwind);
   } else {
+    assert((!EHStack.wouldUnwindBeUB() ||
+            SanOpts.has(SanitizerKind::ExceptionEscape)) &&
+           "If unwind would be UB, we should be here only if sanitizing");
+    MaybeRecordCurrLocForExceptionEscapeUBSan(Loc);
     llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
     CI = Builder.CreateInvoke(IRFuncTy, CalleePtr, Cont, InvokeDest, IRCallArgs,
                               BundleList);
@@ -5657,6 +5664,19 @@
   return Ret;
 }
 
+void CodeGenFunction::MaybeRecordCurrLocForExceptionEscapeUBSan(
+    SourceLocation Loc) {
+  if (!SanOpts.has(SanitizerKind::ExceptionEscape) ||
+      !ExceptionEscapeUBLastInvokeSrcLoc)
+    return;
+  llvm::Constant *CheckSourceLocation = EmitCheckSourceLocation(Loc);
+  Builder.CreateStore(
+      CheckSourceLocation,
+      Address(ExceptionEscapeUBLastInvokeSrcLoc, CheckSourceLocation->getType(),
+              CharUnits::fromQuantity(
+                  ExceptionEscapeUBLastInvokeSrcLoc->getAlign().value())));
+}
+
 CGCallee CGCallee::prepareConcreteCallee(CodeGenFunction &CGF) const {
   if (isVirtual()) {
     const CallExpr *CE = getVirtualCallExpr();
diff --git a/clang/lib/CodeGen/CGCleanup.h b/clang/lib/CodeGen/CGCleanup.h
--- a/clang/lib/CodeGen/CGCleanup.h
+++ b/clang/lib/CodeGen/CGCleanup.h
@@ -86,6 +86,13 @@
     unsigned CleanupSize : 12;
   };
 
+  class UBBitFields {
+    friend class EHUBScope;
+    unsigned : NumCommonBits;
+
+    unsigned IsSanitized : 32 - NumCommonBits;
+  };
+
   class FilterBitFields {
     friend class EHFilterScope;
     unsigned : NumCommonBits;
@@ -97,16 +104,18 @@
     CommonBitFields CommonBits;
     CatchBitFields CatchBits;
     CleanupBitFields CleanupBits;
+    UBBitFields UBBits;
     FilterBitFields FilterBits;
   };
 
 public:
-  enum Kind { Cleanup, Catch, Terminate, Filter };
+  enum Kind { Cleanup, Catch, Terminate, UB, Filter };
 
   EHScope(Kind kind, EHScopeStack::stable_iterator enclosingEHScope)
     : CachedLandingPad(nullptr), CachedEHDispatchBlock(nullptr),
       EnclosingEHScope(enclosingEHScope) {
     CommonBits.Kind = kind;
+    assert(CommonBits.Kind == kind && "Kind overflow?");
   }
 
   Kind getKind() const { return static_cast<Kind>(CommonBits.Kind); }
@@ -487,6 +496,22 @@
   }
 };
 
+/// An exceptions scope which causes UB if any exception reaches it.
+class EHUBScope : public EHScope {
+public:
+  EHUBScope(bool isSanitized, EHScopeStack::stable_iterator enclosingEHScope)
+      : EHScope(UB, enclosingEHScope) {
+    UBBits.IsSanitized = isSanitized;
+    assert(UBBits.IsSanitized == isSanitized && "IsSanitized overflow?");
+  }
+
+  bool getIsSanitized() const { return UBBits.IsSanitized; }
+
+  static size_t getSize() { return sizeof(EHUBScope); }
+
+  static bool classof(const EHScope *scope) { return scope->getKind() == UB; }
+};
+
 /// A non-stable pointer into the scope stack.
 class EHScopeStack::iterator {
   char *Ptr;
@@ -524,6 +549,10 @@
     case EHScope::Terminate:
       Size = EHTerminateScope::getSize();
       break;
+
+    case EHScope::UB:
+      Size = EHUBScope::getSize();
+      break;
     }
     Ptr += llvm::alignTo(Size, ScopeStackAlignment);
     return *this;
@@ -572,6 +601,14 @@
   deallocate(EHTerminateScope::getSize());
 }
 
+inline void EHScopeStack::popUB() {
+  assert(!empty() && "popping exception stack when not empty");
+
+  EHUBScope &scope = cast<EHUBScope>(*begin());
+  InnermostEHScope = scope.getEnclosingEHScope();
+  deallocate(EHUBScope::getSize());
+}
+
 inline EHScopeStack::iterator EHScopeStack::find(stable_iterator sp) const {
   assert(sp.isValid() && "finding invalid savepoint");
   assert(sp.Size <= stable_begin().Size && "finding savepoint after pop");
diff --git a/clang/lib/CodeGen/CGCleanup.cpp b/clang/lib/CodeGen/CGCleanup.cpp
--- a/clang/lib/CodeGen/CGCleanup.cpp
+++ b/clang/lib/CodeGen/CGCleanup.cpp
@@ -152,7 +152,7 @@
   return true;
 }
 
-bool EHScopeStack::requiresLandingPad() const {
+EHScopeStack::iterator EHScopeStack::getInnermostEHScopeForUnwind() const {
   for (stable_iterator si = getInnermostEHScope(); si != stable_end(); ) {
     // Skip lifetime markers.
     if (auto *cleanup = dyn_cast<EHCleanupScope>(&*find(si)))
@@ -160,10 +160,30 @@
         si = cleanup->getEnclosingEHScope();
         continue;
       }
-    return true;
+    return find(si);
   }
 
-  return false;
+  return end();
+}
+
+bool EHScopeStack::wouldUnwindBeUB() const {
+  EHScopeStack::iterator it = getInnermostEHScopeForUnwind();
+  if (it == end())
+    return false;
+
+  // If we are in exception scope which causes UB if any exception reaches it,
+  // and we are not sanitizing for that UB, then the unwind would indeed be UB.
+  // because the callee will not unwind and the landing pad won't be reached.
+  auto *ub = dyn_cast<EHUBScope>(&*it);
+  return ub && !ub->getIsSanitized();
+}
+
+bool EHScopeStack::requiresLandingPad() const {
+  EHScopeStack::iterator it = getInnermostEHScopeForUnwind();
+  if (it == end())
+    return false;
+
+  return !wouldUnwindBeUB();
 }
 
 EHScopeStack::stable_iterator
@@ -188,9 +208,15 @@
   // some, or all cleanups are called before std::terminate. Thus, when
   // terminate is the current EH scope, we may skip adding any EH cleanup
   // scopes.
-  if (InnermostEHScope != stable_end() &&
-      find(InnermostEHScope)->getKind() == EHScope::Terminate)
-    IsEHCleanup = false;
+  //
+  // Likewise, if the exception escaping out of the function would be UB,
+  // skip adding any EH cleanup scopes.
+  if (InnermostEHScope != stable_end()) {
+    if (EHScope::Kind InnermostEHScopeKind = find(InnermostEHScope)->getKind();
+        InnermostEHScopeKind == EHScope::Terminate ||
+        InnermostEHScopeKind == EHScope::UB)
+      IsEHCleanup = false;
+  }
 
   EHCleanupScope *Scope =
     new (Buffer) EHCleanupScope(IsNormalCleanup,
@@ -240,7 +266,8 @@
 }
 
 EHFilterScope *EHScopeStack::pushFilter(unsigned numFilters) {
-  assert(getInnermostEHScope() == stable_end());
+  assert(getInnermostEHScope() == stable_end() ||
+         isa<EHUBScope>(*find(getInnermostEHScope())));
   char *buffer = allocate(EHFilterScope::getSizeForNumFilters(numFilters));
   EHFilterScope *filter = new (buffer) EHFilterScope(numFilters);
   InnermostEHScope = stable_begin();
@@ -270,6 +297,12 @@
   InnermostEHScope = stable_begin();
 }
 
+void EHScopeStack::pushUB(bool isSanitized) {
+  char *Buffer = allocate(EHUBScope::getSize());
+  new (Buffer) EHUBScope(isSanitized, InnermostEHScope);
+  InnermostEHScope = stable_begin();
+}
+
 /// Remove any 'null' fixups on the stack.  However, we can't pop more
 /// fixups than the fixup depth on the innermost normal cleanup, or
 /// else fixups that we try to add to that cleanup will end up in the
diff --git a/clang/lib/CodeGen/CGException.cpp b/clang/lib/CodeGen/CGException.cpp
--- a/clang/lib/CodeGen/CGException.cpp
+++ b/clang/lib/CodeGen/CGException.cpp
@@ -440,6 +440,7 @@
 
 void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E,
                                        bool KeepInsertionPoint) {
+  MaybeRecordCurrLocForExceptionEscapeUBSan(E->getBeginLoc());
   if (const Expr *SubExpr = E->getSubExpr()) {
     QualType ThrowType = SubExpr->getType();
     if (ThrowType->isObjCObjectPointerType()) {
@@ -459,80 +460,12 @@
     EmitBlock(createBasicBlock("throw.cont"));
 }
 
-void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
-  if (!CGM.getLangOpts().CXXExceptions)
-    return;
-
-  const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
-  if (!FD) {
-    // Check if CapturedDecl is nothrow and create terminate scope for it.
-    if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
-      if (CD->isNothrow())
-        EHStack.pushTerminate();
-    }
-    return;
-  }
-  const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
-  if (!Proto)
-    return;
-
-  ExceptionSpecificationType EST = Proto->getExceptionSpecType();
-  // In C++17 and later, 'throw()' aka EST_DynamicNone is treated the same way
-  // as noexcept. In earlier standards, it is handled in this block, along with
-  // 'throw(X...)'.
-  if (EST == EST_Dynamic ||
-      (EST == EST_DynamicNone && !getLangOpts().CPlusPlus17)) {
-    // TODO: Revisit exception specifications for the MS ABI.  There is a way to
-    // encode these in an object file but MSVC doesn't do anything with it.
-    if (getTarget().getCXXABI().isMicrosoft())
-      return;
-    // In Wasm EH we currently treat 'throw()' in the same way as 'noexcept'. In
-    // case of throw with types, we ignore it and print a warning for now.
-    // TODO Correctly handle exception specification in Wasm EH
-    if (CGM.getLangOpts().hasWasmExceptions()) {
-      if (EST == EST_DynamicNone)
-        EHStack.pushTerminate();
-      else
-        CGM.getDiags().Report(D->getLocation(),
-                              diag::warn_wasm_dynamic_exception_spec_ignored)
-            << FD->getExceptionSpecSourceRange();
-      return;
-    }
-    // Currently Emscripten EH only handles 'throw()' but not 'throw' with
-    // types. 'throw()' handling will be done in JS glue code so we don't need
-    // to do anything in that case. Just print a warning message in case of
-    // throw with types.
-    // TODO Correctly handle exception specification in Emscripten EH
-    if (getTarget().getCXXABI() == TargetCXXABI::WebAssembly &&
-        CGM.getLangOpts().getExceptionHandling() ==
-            LangOptions::ExceptionHandlingKind::None &&
-        EST == EST_Dynamic)
-      CGM.getDiags().Report(D->getLocation(),
-                            diag::warn_wasm_dynamic_exception_spec_ignored)
-          << FD->getExceptionSpecSourceRange();
-
-    unsigned NumExceptions = Proto->getNumExceptions();
-    EHFilterScope *Filter = EHStack.pushFilter(NumExceptions);
-
-    for (unsigned I = 0; I != NumExceptions; ++I) {
-      QualType Ty = Proto->getExceptionType(I);
-      QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
-      llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType,
-                                                        /*ForEH=*/true);
-      Filter->setFilter(I, EHType);
-    }
-  } else if (Proto->canThrow() == CT_Cannot) {
-    // noexcept functions are simple terminate scopes.
-    if (!getLangOpts().EHAsynch) // -EHa: HW exception still can occur
-      EHStack.pushTerminate();
-  }
-}
-
 /// Emit the dispatch block for a filter scope if necessary.
 static void emitFilterDispatchBlock(CodeGenFunction &CGF,
                                     EHFilterScope &filterScope) {
   llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock();
-  if (!dispatchBlock) return;
+  if (!dispatchBlock)
+    return;
   if (dispatchBlock->use_empty()) {
     delete dispatchBlock;
     return;
@@ -561,51 +494,128 @@
   // according to the last landing pad the exception was thrown
   // into.  Seriously.
   llvm::Value *exn = CGF.getExceptionFromSlot();
-  CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn)
-    ->setDoesNotReturn();
+  CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn)->setDoesNotReturn();
   CGF.Builder.CreateUnreachable();
 }
 
+bool CodeGenFunction::ExceptionEscapeIsProgramTermination(const Decl *D,
+                                                          bool IsStart) {
+  assert(CGM.getLangOpts().CXXExceptions && "Only for CXX-Exceptions mode.");
+
+  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
+  if (!FD) {
+    // Check if CapturedDecl is nothrow and create terminate scope for it.
+    if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D)) {
+      if (CD->isNothrow())
+        return true;
+    }
+    return false;
+  }
+
+  // As an extension, we define that functions annotated with pure/const attrs
+  // exibit UB on throw, so we don't need to terminate the program.
+  if (FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>())
+    return false;
+
+  const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
+  if (!Proto)
+    return false;
+
+  ExceptionSpecificationType EST = Proto->getExceptionSpecType();
+  // In C++17 and later, 'throw()' aka EST_DynamicNone is treated the same way
+  // as noexcept. In earlier standards, it is handled in this block, along with
+  // 'throw(X...)'.
+  if (EST == EST_Dynamic ||
+      (EST == EST_DynamicNone && !getLangOpts().CPlusPlus17)) {
+    // TODO: Revisit exception specifications for the MS ABI.  There is a way to
+    // encode these in an object file but MSVC doesn't do anything with it.
+    if (getTarget().getCXXABI().isMicrosoft())
+      return false;
+    // In Wasm EH we currently treat 'throw()' in the same way as 'noexcept'. In
+    // case of throw with types, we ignore it and print a warning for now.
+    // TODO Correctly handle exception specification in Wasm EH
+    if (CGM.getLangOpts().hasWasmExceptions()) {
+      if (EST == EST_DynamicNone)
+        return true;
+      else if (IsStart)
+        CGM.getDiags().Report(D->getLocation(),
+                              diag::warn_wasm_dynamic_exception_spec_ignored)
+            << FD->getExceptionSpecSourceRange();
+      return false;
+    }
+    // Currently Emscripten EH only handles 'throw()' but not 'throw' with
+    // types. 'throw()' handling will be done in JS glue code so we don't need
+    // to do anything in that case. Just print a warning message in case of
+    // throw with types.
+    // TODO Correctly handle exception specification in Emscripten EH
+    if (getTarget().getCXXABI() == TargetCXXABI::WebAssembly &&
+        CGM.getLangOpts().getExceptionHandling() ==
+            LangOptions::ExceptionHandlingKind::None &&
+        EST == EST_Dynamic && IsStart)
+      CGM.getDiags().Report(D->getLocation(),
+                            diag::warn_wasm_dynamic_exception_spec_ignored)
+          << FD->getExceptionSpecSourceRange();
+
+    if (IsStart) {
+      unsigned NumExceptions = Proto->getNumExceptions();
+      EHFilterScope *Filter = EHStack.pushFilter(NumExceptions);
+
+      for (unsigned I = 0; I != NumExceptions; ++I) {
+        QualType Ty = Proto->getExceptionType(I);
+        QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
+        llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType,
+                                                          /*ForEH=*/true);
+        Filter->setFilter(I, EHType);
+      }
+    } else {
+      EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin());
+      emitFilterDispatchBlock(*this, filterScope);
+      EHStack.popFilter();
+    }
+  } else if (Proto->canThrow() == CT_Cannot) {
+    // noexcept functions are simple terminate scopes.
+    if (!getLangOpts().EHAsynch) // -EHa: HW exception still can occur
+      return true;
+  }
+  return false;
+}
+
+void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
+  if (!CGM.getLangOpts().CXXExceptions)
+    return;
+
+  // If the LLVM IR function is marked as non-unwinding,
+  // then exception escape is UB. UBSan might be interested in this.
+  if (CurFn->hasFnAttribute(llvm::Attribute::NoUnwind))
+    EHStack.pushUB(/*isSanitized=*/SanOpts.has(SanitizerKind::ExceptionEscape));
+
+  // Does the EH Specification for the current function mandate that the
+  // exception escaping out of the current function is required to cause
+  // program termination?
+  if (ExceptionEscapeIsProgramTermination(D, /*IsStart=*/true)) {
+    assert(CurFn->hasFnAttribute(llvm::Attribute::NoUnwind) &&
+           "Forgot to manifest nounwind function attribute in LLVM IR.");
+    EHStack.pushTerminate();
+  }
+}
+
 void CodeGenFunction::EmitEndEHSpec(const Decl *D) {
   if (!CGM.getLangOpts().CXXExceptions)
     return;
 
-  const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
-  if (!FD) {
-    // Check if CapturedDecl is nothrow and pop terminate scope for it.
-    if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
-      if (CD->isNothrow() && !EHStack.empty())
-        EHStack.popTerminate();
-    }
-    return;
-  }
-  const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
-  if (!Proto)
-    return;
-
-  ExceptionSpecificationType EST = Proto->getExceptionSpecType();
-  if (EST == EST_Dynamic ||
-      (EST == EST_DynamicNone && !getLangOpts().CPlusPlus17)) {
-    // TODO: Revisit exception specifications for the MS ABI.  There is a way to
-    // encode these in an object file but MSVC doesn't do anything with it.
-    if (getTarget().getCXXABI().isMicrosoft())
-      return;
-    // In wasm we currently treat 'throw()' in the same way as 'noexcept'. In
-    // case of throw with types, we ignore it and print a warning for now.
-    // TODO Correctly handle exception specification in wasm
-    if (CGM.getLangOpts().hasWasmExceptions()) {
-      if (EST == EST_DynamicNone)
-        EHStack.popTerminate();
-      return;
-    }
-    EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin());
-    emitFilterDispatchBlock(*this, filterScope);
-    EHStack.popFilter();
-  } else if (Proto->canThrow() == CT_Cannot &&
-              /* possible empty when under async exceptions */
-             !EHStack.empty()) {
+  // Does the EH Specification for the current function mandate that the
+  // exception escaping out of the current function is required to cause
+  // program termination?
+  if (ExceptionEscapeIsProgramTermination(D, /*IsStart=*/false)) {
+    assert(CurFn->hasFnAttribute(llvm::Attribute::NoUnwind) &&
+           "Forgot to manifest nounwind function attribute in LLVM IR.");
     EHStack.popTerminate();
   }
+
+  // If the LLVM IR function is marked as non-unwinding,
+  // then exception escape is UB. UBSan might be interested in this.
+  if (CurFn->hasFnAttribute(llvm::Attribute::NoUnwind))
+    EHStack.popUB();
 }
 
 void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) {
@@ -692,6 +702,13 @@
     case EHScope::Terminate:
       dispatchBlock = getTerminateHandler();
       break;
+
+    case EHScope::UB:
+      if (!cast<EHUBScope>(scope).getIsSanitized())
+        dispatchBlock = getUnreachableBlock();
+      else
+        dispatchBlock = getExceptionEscapeUBHandler();
+      break;
     }
     scope.setCachedEHDispatchBlock(dispatchBlock);
   }
@@ -733,6 +750,11 @@
   case EHScope::Terminate:
     DispatchBlock->setName("terminate");
     break;
+
+  case EHScope::UB:
+    assert(cast<EHUBScope>(EHS).getIsSanitized() && "Only when sanitizing");
+    DispatchBlock->setName("ub");
+    break;
   }
   EHS.setCachedEHDispatchBlock(DispatchBlock);
   return DispatchBlock;
@@ -748,6 +770,7 @@
   case EHScope::Filter:
   case EHScope::Catch:
   case EHScope::Terminate:
+  case EHScope::UB:
     return false;
   }
 
@@ -813,6 +836,10 @@
   switch (innermostEHScope.getKind()) {
   case EHScope::Terminate:
     return getTerminateLandingPad();
+  case EHScope::UB:
+    assert(cast<EHUBScope>(innermostEHScope).getIsSanitized() &&
+           "Only when sanitizing");
+    return getExceptionEscapeUBLandingPad();
 
   case EHScope::Catch:
   case EHScope::Cleanup:
@@ -858,7 +885,8 @@
       continue;
 
     case EHScope::Filter: {
-      assert(I.next() == EHStack.end() && "EH filter is not end of EH stack");
+      assert((I.next() == EHStack.end() || isa<EHUBScope>(*I.next())) &&
+             "EH filter is not end of EH stack");
       assert(!hasCatchAll && "EH filter reached after catch-all");
 
       // Filter scopes get added to the landingpad in weird ways.
@@ -872,7 +900,8 @@
     }
 
     case EHScope::Terminate:
-      // Terminate scopes are basically catch-alls.
+    case EHScope::UB:
+      // Terminate/UB scopes are basically catch-alls.
       assert(!hasCatchAll);
       hasCatchAll = true;
       goto done;
@@ -943,7 +972,7 @@
   Builder.restoreIP(savedIP);
 
   return lpad;
-}
+ }
 
 static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) {
   llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
@@ -1598,6 +1627,120 @@
   return TerminateFunclet;
 }
 
+llvm::BasicBlock *CodeGenFunction::getExceptionEscapeUBSanitizerBB() {
+  assert(SanOpts.has(SanitizerKind::ExceptionEscape) &&
+         "Should only get here if the Exception Escape Sanitizer is enabled.");
+
+  if (ExceptionEscapeUBSanitizerBB)
+    return ExceptionEscapeUBSanitizerBB;
+
+  SanitizerScope SanScope(this);
+
+  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
+
+  // This will get inserted at the end of the function.
+  ExceptionEscapeUBSanitizerBB =
+      createBasicBlock("exception-escape.sanitization");
+  Builder.SetInsertPoint(ExceptionEscapeUBSanitizerBB);
+
+  llvm::Value *Exn = getExceptionFromSlot();
+
+  llvm::Type *SourceLocationTy =
+      EmitCheckSourceLocation(SourceLocation())->getType();
+  ExceptionEscapeUBLastInvokeSrcLoc =
+      CreateTempAlloca(SourceLocationTy, "invoke.srcloc");
+  // The callers are responsible with populating this with relevant information.
+
+  llvm::Value *InvokeSrcLoc = Builder.CreateLoad(
+      Address(ExceptionEscapeUBLastInvokeSrcLoc, SourceLocationTy,
+              CharUnits::fromQuantity(
+                  ExceptionEscapeUBLastInvokeSrcLoc->getAlign().value())),
+      "curr.invoke.srcloc");
+
+  llvm::Value *DynamicData[] = {InvokeSrcLoc, Exn};
+  // FIXME: can we do anything interesting with `Exn`?
+  EmitCheck({std::make_pair(llvm::ConstantInt::getFalse(getLLVMContext()),
+                            SanitizerKind::ExceptionEscape)},
+            SanitizerHandler::ExceptionEscape, /*StaticData=*/{}, DynamicData);
+
+  Builder.CreateUnreachable();
+
+  // Restore the saved insertion state.
+  Builder.restoreIP(SavedIP);
+
+  return ExceptionEscapeUBSanitizerBB;
+}
+
+llvm::BasicBlock *CodeGenFunction::getExceptionEscapeUBLandingPad() {
+  assert(SanOpts.has(SanitizerKind::ExceptionEscape) &&
+         "Should only get here if the Exception Escape Sanitizer is enabled.");
+
+  if (ExceptionEscapeUBLandingPad)
+    return ExceptionEscapeUBLandingPad;
+
+  llvm::BasicBlock *SanBB = getExceptionEscapeUBSanitizerBB();
+
+  SanitizerScope SanScope(this);
+
+  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
+
+  // This will get inserted at the end of the function.
+  ExceptionEscapeUBLandingPad = createBasicBlock("exception-escape.lpad");
+  Builder.SetInsertPoint(ExceptionEscapeUBLandingPad);
+
+  // Tell the backend that this is a landing pad.
+  const EHPersonality &Personality = EHPersonality::get(*this);
+
+  if (!CurFn->hasPersonalityFn())
+    CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));
+
+  llvm::LandingPadInst *LPadInst =
+      Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0);
+  LPadInst->addClause(getCatchAllValue(*this));
+
+  llvm::Value *Exn = nullptr;
+  if (getLangOpts().CPlusPlus)
+    Exn = Builder.CreateExtractValue(LPadInst, 0);
+  Builder.CreateStore(Exn, getExceptionSlot());
+
+  // And just fall through into the actual sanitizer block.
+  Builder.CreateBr(SanBB);
+
+  // Restore the saved insertion state.
+  Builder.restoreIP(SavedIP);
+
+  return ExceptionEscapeUBLandingPad;
+}
+
+llvm::BasicBlock *CodeGenFunction::getExceptionEscapeUBHandler() {
+  assert(SanOpts.has(SanitizerKind::ExceptionEscape) &&
+         "Should only get here if the Exception Escape Sanitizer is enabled.");
+
+  if (ExceptionEscapeUBHandler)
+    return ExceptionEscapeUBHandler;
+
+  llvm::BasicBlock *SanBB = getExceptionEscapeUBSanitizerBB();
+
+  // Set up the UB handler.  This block is inserted at the very
+  // end of the function by FinishFunction.
+  ExceptionEscapeUBHandler = createBasicBlock("exception-escape.handler");
+  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
+  Builder.SetInsertPoint(ExceptionEscapeUBHandler);
+
+  // For C++, the exception is already in the slot, otherwise we need to store
+  // null.
+  if (!getLangOpts().CPlusPlus)
+    Builder.CreateStore(/*Exn=*/nullptr, getExceptionSlot());
+
+  // And just fall through into the actual sanitizer block.
+  Builder.CreateBr(SanBB);
+
+  // Restore the saved insertion state.
+  Builder.restoreIP(SavedIP);
+
+  return ExceptionEscapeUBHandler;
+}
+
 llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
   if (EHResumeBlock) return EHResumeBlock;
 
diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -3190,7 +3190,8 @@
   assert(Kind.countPopulation() == 1);
   if (Kind == SanitizerKind::Function || Kind == SanitizerKind::Vptr)
     return CheckRecoverableKind::AlwaysRecoverable;
-  else if (Kind == SanitizerKind::Return || Kind == SanitizerKind::Unreachable)
+  else if (Kind == SanitizerKind::ExceptionEscape ||
+           Kind == SanitizerKind::Return || Kind == SanitizerKind::Unreachable)
     return CheckRecoverableKind::Unrecoverable;
   else
     return CheckRecoverableKind::Recoverable;
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -134,7 +134,8 @@
   SANITIZER_CHECK(SubOverflow, sub_overflow, 0)                                \
   SANITIZER_CHECK(TypeMismatch, type_mismatch, 1)                              \
   SANITIZER_CHECK(AlignmentAssumption, alignment_assumption, 0)                \
-  SANITIZER_CHECK(VLABoundNotPositive, vla_bound_not_positive, 0)
+  SANITIZER_CHECK(VLABoundNotPositive, vla_bound_not_positive, 0)              \
+  SANITIZER_CHECK(ExceptionEscape, exception_escape, 0)
 
 enum SanitizerHandler {
 #define SANITIZER_CHECK(Enum, Name, Version) Enum,
@@ -1959,11 +1960,19 @@
 
   llvm::BasicBlock *TerminateLandingPad = nullptr;
   llvm::BasicBlock *TerminateHandler = nullptr;
+
+  llvm::BasicBlock *ExceptionEscapeUBSanitizerBB = nullptr;
+  llvm::BasicBlock *ExceptionEscapeUBLandingPad = nullptr;
+  llvm::BasicBlock *ExceptionEscapeUBHandler = nullptr;
+
   llvm::SmallVector<llvm::BasicBlock *, 2> TrapBBs;
 
   /// Terminate funclets keyed by parent funclet pad.
   llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
 
+  llvm::BasicBlock *UBLandingPad = nullptr;
+  llvm::AllocaInst *ExceptionEscapeUBLastInvokeSrcLoc = nullptr;
+
   /// Largest vector width used in ths function. Will be used to create a
   /// function attribute.
   unsigned LargestVectorWidth = 0;
@@ -2382,15 +2391,26 @@
   /// Emit a test that checks if the return value \p RV is nonnull.
   void EmitReturnValueCheck(llvm::Value *RV);
 
+  /// Internal to `EmitStartEHSpec()`/`EmitEndEHSpec()`, do not use directly.
+  bool ExceptionEscapeIsProgramTermination(const Decl *D, bool IsStart);
+
   /// EmitStartEHSpec - Emit the start of the exception spec.
   void EmitStartEHSpec(const Decl *D);
 
   /// EmitEndEHSpec - Emit the end of the exception spec.
   void EmitEndEHSpec(const Decl *D);
 
+  /// getExceptionEscapeUBLandingPad - Return a simple basic block
+  /// that just calls the ubsan handler, if enabled.
+  llvm::BasicBlock *getExceptionEscapeUBSanitizerBB();
+
   /// getTerminateLandingPad - Return a landing pad that just calls terminate.
   llvm::BasicBlock *getTerminateLandingPad();
 
+  /// getExceptionEscapeUBLandingPad - Return a landing pad that just calls
+  /// ubsan handler, if enabled.
+  llvm::BasicBlock *getExceptionEscapeUBLandingPad();
+
   /// getTerminateLandingPad - Return a cleanup funclet that just calls
   /// terminate.
   llvm::BasicBlock *getTerminateFunclet();
@@ -2400,6 +2420,11 @@
   /// a terminate scope encloses a try.
   llvm::BasicBlock *getTerminateHandler();
 
+  /// getExceptionEscapeUBHandler - Return a handler (not a landing pad, just
+  /// a catch handler) that just calls ubsan check, if it is enabled.
+  /// This is used when a UB scope encloses a try.
+  llvm::BasicBlock *getExceptionEscapeUBHandler();
+
   llvm::Type *ConvertTypeForMem(QualType T);
   llvm::Type *ConvertType(QualType T);
   llvm::Type *ConvertType(const TypeDecl *T) {
@@ -4005,6 +4030,8 @@
   //                         Scalar Expression Emission
   //===--------------------------------------------------------------------===//
 
+  void MaybeRecordCurrLocForExceptionEscapeUBSan(SourceLocation Loc);
+
   /// EmitCall - Generate a call of the given function, expecting the given
   /// result type, and using the given argument list which specifies both the
   /// LLVM arguments and the types they were derived from.
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -446,6 +446,9 @@
   EmitIfUsed(*this, TerminateLandingPad);
   EmitIfUsed(*this, TerminateHandler);
   EmitIfUsed(*this, UnreachableBlock);
+  EmitIfUsed(*this, ExceptionEscapeUBSanitizerBB);
+  EmitIfUsed(*this, ExceptionEscapeUBLandingPad);
+  EmitIfUsed(*this, ExceptionEscapeUBHandler);
 
   for (const auto &FuncletAndParent : TerminateFunclets)
     EmitIfUsed(*this, FuncletAndParent.second);
diff --git a/clang/lib/CodeGen/EHScopeStack.h b/clang/lib/CodeGen/EHScopeStack.h
--- a/clang/lib/CodeGen/EHScopeStack.h
+++ b/clang/lib/CodeGen/EHScopeStack.h
@@ -342,6 +342,12 @@
   /// Pops a terminate handler off the stack.
   void popTerminate();
 
+  /// Push a UB handler on the stack.
+  void pushUB(bool isSanitized);
+
+  /// Pops a UB handler off the stack.
+  void popUB();
+
   // Returns true iff the current scope is either empty or contains only
   // lifetime markers, i.e. no real cleanup code
   bool containsOnlyLifetimeMarkers(stable_iterator Old) const;
@@ -349,6 +355,12 @@
   /// Determines whether the exception-scopes stack is empty.
   bool empty() const { return StartOfData == EndOfBuffer; }
 
+  /// An unstable reference to a scope-stack depth.  Invalidated by
+  /// pushes but not pops.
+  class iterator;
+
+  EHScopeStack::iterator getInnermostEHScopeForUnwind() const;
+  bool wouldUnwindBeUB() const;
   bool requiresLandingPad() const;
 
   /// Determines whether there are any normal cleanups on the stack.
@@ -367,11 +379,6 @@
     return InnermostEHScope;
   }
 
-
-  /// An unstable reference to a scope-stack depth.  Invalidated by
-  /// pushes but not pops.
-  class iterator;
-
   /// Returns an iterator pointing to the innermost EH scope.
   iterator begin() const;
 
diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp
--- a/clang/lib/Driver/SanitizerArgs.cpp
+++ b/clang/lib/Driver/SanitizerArgs.cpp
@@ -58,8 +58,9 @@
     SanitizerKind::Undefined | SanitizerKind::Integer |
     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
     SanitizerKind::FloatDivideByZero | SanitizerKind::ObjCCast;
-static const SanitizerMask Unrecoverable =
-    SanitizerKind::Unreachable | SanitizerKind::Return;
+static const SanitizerMask Unrecoverable = SanitizerKind::Unreachable |
+                                           SanitizerKind::Return |
+                                           SanitizerKind::ExceptionEscape;
 static const SanitizerMask AlwaysRecoverable = SanitizerKind::KernelAddress |
                                                SanitizerKind::KernelHWAddress |
                                                SanitizerKind::KCFI;
diff --git a/clang/test/CodeGen/windows-seh-EHa-CppCondiTemps.cpp b/clang/test/CodeGen/windows-seh-EHa-CppCondiTemps.cpp
--- a/clang/test/CodeGen/windows-seh-EHa-CppCondiTemps.cpp
+++ b/clang/test/CodeGen/windows-seh-EHa-CppCondiTemps.cpp
@@ -1,5 +1,8 @@
 // RUN: %clang_cc1 -triple x86_64-windows -fasync-exceptions -fcxx-exceptions -fexceptions -fms-extensions -x c++ -Wno-implicit-function-declaration -S -emit-llvm %s -o - | FileCheck %s
 
+// FIXME: this check appears to be miscompiled?
+// XFAIL: *
+
 // CHECK: define dso_local noundef i32 @"?bar@@YAHHVB1@@VB2@@@Z"
 // CHECK: %coerce.dive1 = getelementptr inbounds %class.B2
 // CHECK: %coerce.dive2 = getelementptr inbounds %class.B1
diff --git a/clang/test/CodeGenCXX/catch-exception-escape.cpp b/clang/test/CodeGenCXX/catch-exception-escape.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/CodeGenCXX/catch-exception-escape.cpp
@@ -0,0 +1,1258 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+// RUN: %clang_cc1                                                                    -emit-llvm %s -o - -triple x86_64-linux-gnu              -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-NO-EXCEPTIONS
+// RUN: %clang_cc1                                                                    -emit-llvm %s -o - -triple x86_64-linux-gnu -fexceptions -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-NOSANITIZE
+// RUN: %clang_cc1 -fsanitize=exception-escape                                        -emit-llvm %s -o - -triple x86_64-linux-gnu -fexceptions -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-SANITIZE-NORECOVER
+// RUN: %clang_cc1 -fsanitize=exception-escape -fno-sanitize-recover=exception-escape -emit-llvm %s -o - -triple x86_64-linux-gnu -fexceptions -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-SANITIZE-NORECOVER
+// RUN: %clang_cc1 -fsanitize=exception-escape -fsanitize-trap=exception-escape       -emit-llvm %s -o - -triple x86_64-linux-gnu -fexceptions -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-SANITIZE-TRAP
+
+void will_throw(int line = __builtin_LINE());
+void might_throw(int line = __builtin_LINE());
+void will_not_throw(int line = __builtin_LINE()) noexcept;
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z30footgun_exception_escape_is_ubi
+// CHECK-NO-EXCEPTIONS-SAME: (i32 noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 100) #[[ATTR4:[0-9]+]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END]]
+// CHECK-NO-EXCEPTIONS:       if.end:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then2:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 300) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END3]]
+// CHECK-NO-EXCEPTIONS:       if.end3:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP4]], label [[IF_THEN5:%.*]], label [[IF_END6:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then5:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 500)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END6]]
+// CHECK-NO-EXCEPTIONS:       if.end6:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP3:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP7:%.*]] = icmp eq i32 [[TMP3]], 5
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP7]], label [[IF_THEN8:%.*]], label [[IF_END9:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then8:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 900)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END9]]
+// CHECK-NO-EXCEPTIONS:       if.end9:
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-NOSANITIZE: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-NOSANITIZE-LABEL: define {{[^@]+}}@_Z30footgun_exception_escape_is_ubi
+// CHECK-NOSANITIZE-SAME: (i32 noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-NOSANITIZE-NEXT:  entry:
+// CHECK-NOSANITIZE-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[X12:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NOSANITIZE:       if.then:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z10will_throwi(i32 noundef 100) #[[ATTR7:[0-9]+]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END]]
+// CHECK-NOSANITIZE:       if.end:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+// CHECK-NOSANITIZE:       if.then2:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z10will_throwi(i32 noundef 300) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END3]]
+// CHECK-NOSANITIZE:       if.end3:
+// CHECK-NOSANITIZE-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP4]], label [[IF_THEN5:%.*]], label [[IF_END6:%.*]]
+// CHECK-NOSANITIZE:       if.then5:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-NOSANITIZE:       lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH:%.*]]
+// CHECK-NOSANITIZE:       catch:
+// CHECK-NOSANITIZE-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    call void @_Z11might_throwi(i32 noundef 700) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    call void @__cxa_rethrow() #[[ATTR8:[0-9]+]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       try.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END6]]
+// CHECK-NOSANITIZE:       if.end6:
+// CHECK-NOSANITIZE-NEXT:    [[TMP7:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP7:%.*]] = icmp eq i32 [[TMP7]], 5
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP7]], label [[IF_THEN8:%.*]], label [[IF_END15:%.*]]
+// CHECK-NOSANITIZE:       if.then8:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT10:%.*]] unwind label [[LPAD9:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont10:
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT14:%.*]]
+// CHECK-NOSANITIZE:       lpad9:
+// CHECK-NOSANITIZE-NEXT:    [[TMP8:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr @_ZTIi
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP9]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP10:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP10]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-NOSANITIZE:       catch.dispatch:
+// CHECK-NOSANITIZE-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP11:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP11]]
+// CHECK-NOSANITIZE-NEXT:    br i1 [[MATCHES]], label [[CATCH11:%.*]], label [[UNREACHABLE:%.*]]
+// CHECK-NOSANITIZE:       catch11:
+// CHECK-NOSANITIZE-NEXT:    [[EXN13:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP12:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN13]]) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP13:%.*]] = load i32, ptr [[TMP12]], align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP13]], ptr [[X12]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP14:%.*]] = load i32, ptr [[X12]], align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP14]], ptr [[EXCEPTION]], align 16
+// CHECK-NOSANITIZE-NEXT:    call void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR8]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       try.cont14:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END15]]
+// CHECK-NOSANITIZE:       if.end15:
+// CHECK-NOSANITIZE-NEXT:    ret void
+// CHECK-NOSANITIZE:       unreachable:
+// CHECK-NOSANITIZE-NEXT:    unreachable
+//
+// CHECK-SANITIZE-NORECOVER: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-SANITIZE-NORECOVER-LABEL: define {{[^@]+}}@_Z30footgun_exception_escape_is_ubi
+// CHECK-SANITIZE-NORECOVER-SAME: (i32 noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-NORECOVER-NEXT:  entry:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[INVOKE_SRCLOC:%.*]] = alloca { ptr, i32, i32 }, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP:%.*]] = alloca { ptr, i32, i32 }, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 100, i32 5 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 100)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-NORECOVER:       handler.exception_escape:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } [[CURR_INVOKE_SRCLOC:%.*]], ptr [[TMP]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP1:%.*]] = ptrtoint ptr [[TMP]] to i64, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP2:%.*]] = ptrtoint ptr [[EXN19:%.*]] to i64, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__ubsan_handle_exception_escape(i64 [[TMP1]], i64 [[TMP2]]) #[[ATTR8:[0-9]+]], !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER:       cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER:       if.end:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR9:[0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP3:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP3]], 3
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then2:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 300, i32 5 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 300)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT3:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont3:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END4]]
+// CHECK-SANITIZE-NORECOVER:       if.end4:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP4:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP4]], 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END9:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then6:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 500, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont7:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP5:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP6:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP6]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP7:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP7]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP8:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 700, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont8:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 800, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_rethrow() #[[ATTR10:[0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       try.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END9]]
+// CHECK-SANITIZE-NORECOVER:       if.end9:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP9:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP9]], 5
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END18:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then11:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 900, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont13:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT17:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad12:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP10:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr @_ZTIi
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP11:%.*]] = extractvalue { ptr, i32 } [[TMP10]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP11]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP12:%.*]] = extractvalue { ptr, i32 } [[TMP10]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP12]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch.dispatch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP13:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP13]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[EXCEPTION_ESCAPE_HANDLER:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch14:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP14:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP15:%.*]] = load i32, ptr [[TMP14]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP15]], ptr [[X15]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 1000, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP16:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP16]], ptr [[EXCEPTION]], align 16
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR10]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       try.cont17:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END18]]
+// CHECK-SANITIZE-NORECOVER:       if.end18:
+// CHECK-SANITIZE-NORECOVER-NEXT:    ret void
+// CHECK-SANITIZE-NORECOVER:       unreachable:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+// CHECK-SANITIZE-NORECOVER:       exception-escape.sanitization:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN19]] = load ptr, ptr [[EXN_SLOT]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CURR_INVOKE_SRCLOC]] = load { ptr, i32, i32 }, ptr [[INVOKE_SRCLOC]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 false, label [[CONT:%.*]], label [[HANDLER_EXCEPTION_ESCAPE:%.*]], !prof [[PROF3:![0-9]+]], !nosanitize !2
+// CHECK-SANITIZE-NORECOVER:       exception-escape.lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP17:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP18:%.*]] = extractvalue { ptr, i32 } [[TMP17]], 0, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP18]], ptr [[EXN_SLOT]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EXCEPTION_ESCAPE_SANITIZATION:%.*]], !nosanitize !2
+// CHECK-SANITIZE-NORECOVER:       exception-escape.handler:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EXCEPTION_ESCAPE_SANITIZATION]]
+//
+// CHECK-SANITIZE-TRAP: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-SANITIZE-TRAP-LABEL: define {{[^@]+}}@_Z30footgun_exception_escape_is_ubi
+// CHECK-SANITIZE-TRAP-SAME: (i32 noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-TRAP-NEXT:  entry:
+// CHECK-SANITIZE-TRAP-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[INVOKE_SRCLOC:%.*]] = alloca { ptr, i32, i32 }, align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then:
+// CHECK-SANITIZE-TRAP-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 100, i32 5 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 100)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-TRAP:       trap:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @llvm.ubsantrap(i8 25) #[[ATTR8:[0-9]+]], !nosanitize !2
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable, !nosanitize !2
+// CHECK-SANITIZE-TRAP:       cont:
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable, !nosanitize !2
+// CHECK-SANITIZE-TRAP:       if.end:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR9:[0-9]+]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then2:
+// CHECK-SANITIZE-TRAP-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 300, i32 5 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 300)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT3:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-TRAP:       invoke.cont3:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END4]]
+// CHECK-SANITIZE-TRAP:       if.end4:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END9:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then6:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 500, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont7:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-TRAP:       lpad:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-TRAP:       catch:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 700, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-TRAP:       invoke.cont8:
+// CHECK-SANITIZE-TRAP-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 800, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @__cxa_rethrow() #[[ATTR10:[0-9]+]]
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-TRAP:       try.cont:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END9]]
+// CHECK-SANITIZE-TRAP:       if.end9:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP7:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP7]], 5
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END18:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then11:
+// CHECK-SANITIZE-TRAP-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 900, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont13:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[TRY_CONT17:%.*]]
+// CHECK-SANITIZE-TRAP:       lpad12:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP8:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr @_ZTIi
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP9]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP10:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP10]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-SANITIZE-TRAP:       catch.dispatch:
+// CHECK-SANITIZE-TRAP-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP11:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP11]]
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[EXCEPTION_ESCAPE_HANDLER:%.*]]
+// CHECK-SANITIZE-TRAP:       catch14:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP12:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP13:%.*]] = load i32, ptr [[TMP12]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP13]], ptr [[X15]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 1000, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP14:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP14]], ptr [[EXCEPTION]], align 16
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR10]]
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[UNREACHABLE]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-TRAP:       try.cont17:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END18]]
+// CHECK-SANITIZE-TRAP:       if.end18:
+// CHECK-SANITIZE-TRAP-NEXT:    ret void
+// CHECK-SANITIZE-TRAP:       unreachable:
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable
+// CHECK-SANITIZE-TRAP:       exception-escape.sanitization:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN19:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8, !nosanitize !2
+// CHECK-SANITIZE-TRAP-NEXT:    [[CURR_INVOKE_SRCLOC:%.*]] = load { ptr, i32, i32 }, ptr [[INVOKE_SRCLOC]], align 8, !nosanitize !2
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 false, label [[CONT:%.*]], label [[TRAP:%.*]], !nosanitize !2
+// CHECK-SANITIZE-TRAP:       exception-escape.lpad:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP15:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null, !nosanitize !2
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP16:%.*]] = extractvalue { ptr, i32 } [[TMP15]], 0, !nosanitize !2
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP16]], ptr [[EXN_SLOT]], align 8, !nosanitize !2
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[EXCEPTION_ESCAPE_SANITIZATION:%.*]], !nosanitize !2
+// CHECK-SANITIZE-TRAP:       exception-escape.handler:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[EXCEPTION_ESCAPE_SANITIZATION]]
+//
+void __attribute__((pure)) footgun_exception_escape_is_ub(int x) {
+  if (x == 2) {
+#line 100
+    will_throw();
+  }
+#line 200
+  will_not_throw();
+  if (x == 3) {
+#line 300
+    will_throw();
+  }
+  if (x == 4) {
+    try {
+#line 400
+      will_not_throw();
+#line 500
+      will_throw();
+    } catch (...) {
+#line 600
+      will_not_throw();
+#line 700
+      might_throw();
+#line 800
+      throw;
+    }
+  }
+  if (x == 5) {
+    try {
+#line 900
+      will_throw();
+    } catch (int x) {
+#line 1000
+      throw x;
+    }
+  }
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z39exception_escape_is_program_terminationi
+// CHECK-NO-EXCEPTIONS-SAME: (i32 noundef [[X:%.*]]) #[[ATTR3:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 100)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END]]
+// CHECK-NO-EXCEPTIONS:       if.end:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then2:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 300)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END3]]
+// CHECK-NO-EXCEPTIONS:       if.end3:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP4]], label [[IF_THEN5:%.*]], label [[IF_END6:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then5:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 500)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END6]]
+// CHECK-NO-EXCEPTIONS:       if.end6:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP3:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP7:%.*]] = icmp eq i32 [[TMP3]], 5
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP7]], label [[IF_THEN8:%.*]], label [[IF_END9:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then8:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 900)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END9]]
+// CHECK-NO-EXCEPTIONS:       if.end9:
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-NOSANITIZE: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NOSANITIZE-LABEL: define {{[^@]+}}@_Z39exception_escape_is_program_terminationi
+// CHECK-NOSANITIZE-SAME: (i32 noundef [[X:%.*]]) #[[ATTR4:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-NOSANITIZE-NEXT:  entry:
+// CHECK-NOSANITIZE-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NOSANITIZE:       if.then:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 100)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END]]
+// CHECK-NOSANITIZE:       if.end:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-NOSANITIZE:       if.then2:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 300)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT3:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       invoke.cont3:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END4]]
+// CHECK-NOSANITIZE:       if.end4:
+// CHECK-NOSANITIZE-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END9:%.*]]
+// CHECK-NOSANITIZE:       if.then6:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont7:
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-NOSANITIZE:       lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH:%.*]]
+// CHECK-NOSANITIZE:       catch:
+// CHECK-NOSANITIZE-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       invoke.cont8:
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_rethrow() #[[ATTR8]]
+// CHECK-NOSANITIZE-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       try.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END9]]
+// CHECK-NOSANITIZE:       if.end9:
+// CHECK-NOSANITIZE-NEXT:    [[TMP7:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP7]], 5
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END18:%.*]]
+// CHECK-NOSANITIZE:       if.then11:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont13:
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT17:%.*]]
+// CHECK-NOSANITIZE:       lpad12:
+// CHECK-NOSANITIZE-NEXT:    [[TMP8:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr @_ZTIi
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP9]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP10:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP10]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-NOSANITIZE:       catch.dispatch:
+// CHECK-NOSANITIZE-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP11:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP11]]
+// CHECK-NOSANITIZE-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[TERMINATE_HANDLER:%.*]]
+// CHECK-NOSANITIZE:       catch14:
+// CHECK-NOSANITIZE-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP12:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP13:%.*]] = load i32, ptr [[TMP12]], align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP13]], ptr [[X15]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP14:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP14]], ptr [[EXCEPTION]], align 16
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR8]]
+// CHECK-NOSANITIZE-NEXT:    to label [[UNREACHABLE]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       try.cont17:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END18]]
+// CHECK-NOSANITIZE:       if.end18:
+// CHECK-NOSANITIZE-NEXT:    ret void
+// CHECK-NOSANITIZE:       terminate.lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP15:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP16:%.*]] = extractvalue { ptr, i32 } [[TMP15]], 0
+// CHECK-NOSANITIZE-NEXT:    call void @__clang_call_terminate(ptr [[TMP16]]) #[[ATTR9:[0-9]+]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       terminate.handler:
+// CHECK-NOSANITIZE-NEXT:    [[EXN19:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    call void @__clang_call_terminate(ptr [[EXN19]]) #[[ATTR9]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       unreachable:
+// CHECK-NOSANITIZE-NEXT:    unreachable
+//
+// CHECK-SANITIZE-NORECOVER: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-SANITIZE-NORECOVER-LABEL: define {{[^@]+}}@_Z39exception_escape_is_program_terminationi
+// CHECK-SANITIZE-NORECOVER-SAME: (i32 noundef [[X:%.*]]) #[[ATTR5:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-NORECOVER-NEXT:  entry:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 100)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-NORECOVER:       if.end:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then2:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 300)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT3:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont3:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END4]]
+// CHECK-SANITIZE-NORECOVER:       if.end4:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END9:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then6:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont7:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont8:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_rethrow() #[[ATTR10]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       try.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END9]]
+// CHECK-SANITIZE-NORECOVER:       if.end9:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP7:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP7]], 5
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END18:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then11:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont13:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT17:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad12:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP8:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr @_ZTIi
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP9]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP10:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP10]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch.dispatch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP11:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP11]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[TERMINATE_HANDLER:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch14:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP12:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP13:%.*]] = load i32, ptr [[TMP12]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP13]], ptr [[X15]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP14:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP14]], ptr [[EXCEPTION]], align 16
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR10]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       try.cont17:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END18]]
+// CHECK-SANITIZE-NORECOVER:       if.end18:
+// CHECK-SANITIZE-NORECOVER-NEXT:    ret void
+// CHECK-SANITIZE-NORECOVER:       terminate.lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP15:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP16:%.*]] = extractvalue { ptr, i32 } [[TMP15]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__clang_call_terminate(ptr [[TMP16]]) #[[ATTR8]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+// CHECK-SANITIZE-NORECOVER:       terminate.handler:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN19:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__clang_call_terminate(ptr [[EXN19]]) #[[ATTR8]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+// CHECK-SANITIZE-NORECOVER:       unreachable:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+//
+// CHECK-SANITIZE-TRAP: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-SANITIZE-TRAP-LABEL: define {{[^@]+}}@_Z39exception_escape_is_program_terminationi
+// CHECK-SANITIZE-TRAP-SAME: (i32 noundef [[X:%.*]]) #[[ATTR5:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-TRAP-NEXT:  entry:
+// CHECK-SANITIZE-TRAP-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then:
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 100)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-TRAP:       if.end:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then2:
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 300)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT3:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-TRAP:       invoke.cont3:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END4]]
+// CHECK-SANITIZE-TRAP:       if.end4:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END9:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then6:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont7:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-TRAP:       lpad:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-TRAP:       catch:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-TRAP:       invoke.cont8:
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @__cxa_rethrow() #[[ATTR10]]
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-TRAP:       try.cont:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END9]]
+// CHECK-SANITIZE-TRAP:       if.end9:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP7:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP7]], 5
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END18:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then11:
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont13:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[TRY_CONT17:%.*]]
+// CHECK-SANITIZE-TRAP:       lpad12:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP8:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr @_ZTIi
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP9]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP10:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP10]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-SANITIZE-TRAP:       catch.dispatch:
+// CHECK-SANITIZE-TRAP-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP11:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP11]]
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[TERMINATE_HANDLER:%.*]]
+// CHECK-SANITIZE-TRAP:       catch14:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP12:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP13:%.*]] = load i32, ptr [[TMP12]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP13]], ptr [[X15]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP14:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP14]], ptr [[EXCEPTION]], align 16
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR10]]
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[UNREACHABLE]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-TRAP:       try.cont17:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END18]]
+// CHECK-SANITIZE-TRAP:       if.end18:
+// CHECK-SANITIZE-TRAP-NEXT:    ret void
+// CHECK-SANITIZE-TRAP:       terminate.lpad:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP15:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP16:%.*]] = extractvalue { ptr, i32 } [[TMP15]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    call void @__clang_call_terminate(ptr [[TMP16]]) #[[ATTR8]]
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable
+// CHECK-SANITIZE-TRAP:       terminate.handler:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN19:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    call void @__clang_call_terminate(ptr [[EXN19]]) #[[ATTR8]]
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable
+// CHECK-SANITIZE-TRAP:       unreachable:
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable
+//
+void exception_escape_is_program_termination(int x) noexcept {
+  if (x == 2) {
+#line 100
+    will_throw();
+  }
+#line 200
+  will_not_throw();
+  if (x == 3) {
+#line 300
+    will_throw();
+  }
+  if (x == 4) {
+    try {
+#line 400
+      will_not_throw();
+#line 500
+      will_throw();
+    } catch (...) {
+#line 600
+      will_not_throw();
+#line 700
+      might_throw();
+#line 800
+      throw;
+    }
+  }
+  if (x == 5) {
+    try {
+#line 900
+      will_throw();
+    } catch (int x) {
+#line 1000
+      throw x;
+    }
+  }
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z22exception_escape_is_oki
+// CHECK-NO-EXCEPTIONS-SAME: (i32 noundef [[X:%.*]]) #[[ATTR3]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 100)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END]]
+// CHECK-NO-EXCEPTIONS:       if.end:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then2:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 300)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END3]]
+// CHECK-NO-EXCEPTIONS:       if.end3:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP4]], label [[IF_THEN5:%.*]], label [[IF_END6:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then5:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 500)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END6]]
+// CHECK-NO-EXCEPTIONS:       if.end6:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP3:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP7:%.*]] = icmp eq i32 [[TMP3]], 5
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP7]], label [[IF_THEN8:%.*]], label [[IF_END9:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then8:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 900)
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END9]]
+// CHECK-NO-EXCEPTIONS:       if.end9:
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-NOSANITIZE: Function Attrs: mustprogress noinline optnone
+// CHECK-NOSANITIZE-LABEL: define {{[^@]+}}@_Z22exception_escape_is_oki
+// CHECK-NOSANITIZE-SAME: (i32 noundef [[X:%.*]]) #[[ATTR6:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-NOSANITIZE-NEXT:  entry:
+// CHECK-NOSANITIZE-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NOSANITIZE:       if.then:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z10will_throwi(i32 noundef 100)
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END]]
+// CHECK-NOSANITIZE:       if.end:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+// CHECK-NOSANITIZE:       if.then2:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z10will_throwi(i32 noundef 300)
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END3]]
+// CHECK-NOSANITIZE:       if.end3:
+// CHECK-NOSANITIZE-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP4]], label [[IF_THEN5:%.*]], label [[IF_END9:%.*]]
+// CHECK-NOSANITIZE:       if.then5:
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-NOSANITIZE:       lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH:%.*]]
+// CHECK-NOSANITIZE:       catch:
+// CHECK-NOSANITIZE-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont7:
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_rethrow() #[[ATTR8]]
+// CHECK-NOSANITIZE-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD6]]
+// CHECK-NOSANITIZE:       lpad6:
+// CHECK-NOSANITIZE-NEXT:    [[TMP7:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    cleanup
+// CHECK-NOSANITIZE-NEXT:    [[TMP8:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP8]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP9]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_end_catch()
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont8:
+// CHECK-NOSANITIZE-NEXT:    br label [[EH_RESUME:%.*]]
+// CHECK-NOSANITIZE:       try.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END9]]
+// CHECK-NOSANITIZE:       if.end9:
+// CHECK-NOSANITIZE-NEXT:    [[TMP10:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP10]], 5
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END19:%.*]]
+// CHECK-NOSANITIZE:       if.then11:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont13:
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT18:%.*]]
+// CHECK-NOSANITIZE:       lpad12:
+// CHECK-NOSANITIZE-NEXT:    [[TMP11:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr @_ZTIi
+// CHECK-NOSANITIZE-NEXT:    [[TMP12:%.*]] = extractvalue { ptr, i32 } [[TMP11]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP12]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP13:%.*]] = extractvalue { ptr, i32 } [[TMP11]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP13]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-NOSANITIZE:       catch.dispatch:
+// CHECK-NOSANITIZE-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP14:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP14]]
+// CHECK-NOSANITIZE-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[EH_RESUME]]
+// CHECK-NOSANITIZE:       catch14:
+// CHECK-NOSANITIZE-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP15:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP16:%.*]] = load i32, ptr [[TMP15]], align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP16]], ptr [[X15]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    [[TMP17:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP17]], ptr [[EXCEPTION]], align 16
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR8]]
+// CHECK-NOSANITIZE-NEXT:    to label [[UNREACHABLE]] unwind label [[LPAD17:%.*]]
+// CHECK-NOSANITIZE:       lpad17:
+// CHECK-NOSANITIZE-NEXT:    [[TMP18:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    cleanup
+// CHECK-NOSANITIZE-NEXT:    [[TMP19:%.*]] = extractvalue { ptr, i32 } [[TMP18]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP19]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP20:%.*]] = extractvalue { ptr, i32 } [[TMP18]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP20]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    call void @__cxa_end_catch() #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    br label [[EH_RESUME]]
+// CHECK-NOSANITIZE:       try.cont18:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END19]]
+// CHECK-NOSANITIZE:       if.end19:
+// CHECK-NOSANITIZE-NEXT:    ret void
+// CHECK-NOSANITIZE:       eh.resume:
+// CHECK-NOSANITIZE-NEXT:    [[EXN20:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[SEL21:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[LPAD_VAL:%.*]] = insertvalue { ptr, i32 } undef, ptr [[EXN20]], 0
+// CHECK-NOSANITIZE-NEXT:    [[LPAD_VAL22:%.*]] = insertvalue { ptr, i32 } [[LPAD_VAL]], i32 [[SEL21]], 1
+// CHECK-NOSANITIZE-NEXT:    resume { ptr, i32 } [[LPAD_VAL22]]
+// CHECK-NOSANITIZE:       terminate.lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP21:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP22:%.*]] = extractvalue { ptr, i32 } [[TMP21]], 0
+// CHECK-NOSANITIZE-NEXT:    call void @__clang_call_terminate(ptr [[TMP22]]) #[[ATTR9]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       unreachable:
+// CHECK-NOSANITIZE-NEXT:    unreachable
+//
+// CHECK-SANITIZE-NORECOVER: Function Attrs: mustprogress noinline optnone
+// CHECK-SANITIZE-NORECOVER-LABEL: define {{[^@]+}}@_Z22exception_escape_is_oki
+// CHECK-SANITIZE-NORECOVER-SAME: (i32 noundef [[X:%.*]]) #[[ATTR7:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-NORECOVER-NEXT:  entry:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z10will_throwi(i32 noundef 100)
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-NORECOVER:       if.end:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then2:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z10will_throwi(i32 noundef 300)
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END3]]
+// CHECK-SANITIZE-NORECOVER:       if.end3:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP4]], label [[IF_THEN5:%.*]], label [[IF_END9:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then5:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont7:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_rethrow() #[[ATTR10]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD6]]
+// CHECK-SANITIZE-NORECOVER:       lpad6:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP7:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    cleanup
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP8:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP8]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP9]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_end_catch()
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont8:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EH_RESUME:%.*]]
+// CHECK-SANITIZE-NORECOVER:       try.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END9]]
+// CHECK-SANITIZE-NORECOVER:       if.end9:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP10:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP10]], 5
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END19:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then11:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont13:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT18:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad12:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP11:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr @_ZTIi
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP12:%.*]] = extractvalue { ptr, i32 } [[TMP11]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP12]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP13:%.*]] = extractvalue { ptr, i32 } [[TMP11]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP13]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       catch.dispatch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP14:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP14]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[EH_RESUME]]
+// CHECK-SANITIZE-NORECOVER:       catch14:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP15:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP16:%.*]] = load i32, ptr [[TMP15]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP16]], ptr [[X15]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP17:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP17]], ptr [[EXCEPTION]], align 16
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR10]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE]] unwind label [[LPAD17:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad17:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP18:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    cleanup
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP19:%.*]] = extractvalue { ptr, i32 } [[TMP18]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP19]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP20:%.*]] = extractvalue { ptr, i32 } [[TMP18]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP20]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__cxa_end_catch() #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EH_RESUME]]
+// CHECK-SANITIZE-NORECOVER:       try.cont18:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END19]]
+// CHECK-SANITIZE-NORECOVER:       if.end19:
+// CHECK-SANITIZE-NORECOVER-NEXT:    ret void
+// CHECK-SANITIZE-NORECOVER:       eh.resume:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN20:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[SEL21:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[LPAD_VAL:%.*]] = insertvalue { ptr, i32 } undef, ptr [[EXN20]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[LPAD_VAL22:%.*]] = insertvalue { ptr, i32 } [[LPAD_VAL]], i32 [[SEL21]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    resume { ptr, i32 } [[LPAD_VAL22]]
+// CHECK-SANITIZE-NORECOVER:       terminate.lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP21:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP22:%.*]] = extractvalue { ptr, i32 } [[TMP21]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__clang_call_terminate(ptr [[TMP22]]) #[[ATTR8]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+// CHECK-SANITIZE-NORECOVER:       unreachable:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+//
+// CHECK-SANITIZE-TRAP: Function Attrs: mustprogress noinline optnone
+// CHECK-SANITIZE-TRAP-LABEL: define {{[^@]+}}@_Z22exception_escape_is_oki
+// CHECK-SANITIZE-TRAP-SAME: (i32 noundef [[X:%.*]]) #[[ATTR7:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-TRAP-NEXT:  entry:
+// CHECK-SANITIZE-TRAP-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[X15:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 2
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z10will_throwi(i32 noundef 100)
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-TRAP:       if.end:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 200) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 3
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then2:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z10will_throwi(i32 noundef 300)
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END3]]
+// CHECK-SANITIZE-TRAP:       if.end3:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP4:%.*]] = icmp eq i32 [[TMP2]], 4
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP4]], label [[IF_THEN5:%.*]], label [[IF_END9:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then5:
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 400) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 500)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-TRAP:       lpad:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP3:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP4]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP3]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP5]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-TRAP:       catch:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP6:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    call void @_Z14will_not_throwi(i32 noundef 600) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z11might_throwi(i32 noundef 700)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont7:
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @__cxa_rethrow() #[[ATTR10]]
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD6]]
+// CHECK-SANITIZE-TRAP:       lpad6:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP7:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    cleanup
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP8:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP8]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP9]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @__cxa_end_catch()
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT8:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont8:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[EH_RESUME:%.*]]
+// CHECK-SANITIZE-TRAP:       try.cont:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END9]]
+// CHECK-SANITIZE-TRAP:       if.end9:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP10:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[CMP10:%.*]] = icmp eq i32 [[TMP10]], 5
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[CMP10]], label [[IF_THEN11:%.*]], label [[IF_END19:%.*]]
+// CHECK-SANITIZE-TRAP:       if.then11:
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @_Z10will_throwi(i32 noundef 900)
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[LPAD12:%.*]]
+// CHECK-SANITIZE-TRAP:       invoke.cont13:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[TRY_CONT18:%.*]]
+// CHECK-SANITIZE-TRAP:       lpad12:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP11:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr @_ZTIi
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP12:%.*]] = extractvalue { ptr, i32 } [[TMP11]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP12]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP13:%.*]] = extractvalue { ptr, i32 } [[TMP11]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP13]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[CATCH_DISPATCH:%.*]]
+// CHECK-SANITIZE-TRAP:       catch.dispatch:
+// CHECK-SANITIZE-TRAP-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP14:%.*]] = call i32 @llvm.eh.typeid.for(ptr @_ZTIi) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[MATCHES:%.*]] = icmp eq i32 [[SEL]], [[TMP14]]
+// CHECK-SANITIZE-TRAP-NEXT:    br i1 [[MATCHES]], label [[CATCH14:%.*]], label [[EH_RESUME]]
+// CHECK-SANITIZE-TRAP:       catch14:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN16:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP15:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN16]]) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP16:%.*]] = load i32, ptr [[TMP15]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP16]], ptr [[X15]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXCEPTION:%.*]] = call ptr @__cxa_allocate_exception(i64 4) #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP17:%.*]] = load i32, ptr [[X15]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP17]], ptr [[EXCEPTION]], align 16
+// CHECK-SANITIZE-TRAP-NEXT:    invoke void @__cxa_throw(ptr [[EXCEPTION]], ptr @_ZTIi, ptr null) #[[ATTR10]]
+// CHECK-SANITIZE-TRAP-NEXT:    to label [[UNREACHABLE]] unwind label [[LPAD17:%.*]]
+// CHECK-SANITIZE-TRAP:       lpad17:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP18:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    cleanup
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP19:%.*]] = extractvalue { ptr, i32 } [[TMP18]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    store ptr [[TMP19]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP20:%.*]] = extractvalue { ptr, i32 } [[TMP18]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    store i32 [[TMP20]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    call void @__cxa_end_catch() #[[ATTR9]]
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[EH_RESUME]]
+// CHECK-SANITIZE-TRAP:       try.cont18:
+// CHECK-SANITIZE-TRAP-NEXT:    br label [[IF_END19]]
+// CHECK-SANITIZE-TRAP:       if.end19:
+// CHECK-SANITIZE-TRAP-NEXT:    ret void
+// CHECK-SANITIZE-TRAP:       eh.resume:
+// CHECK-SANITIZE-TRAP-NEXT:    [[EXN20:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-TRAP-NEXT:    [[SEL21:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-TRAP-NEXT:    [[LPAD_VAL:%.*]] = insertvalue { ptr, i32 } undef, ptr [[EXN20]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    [[LPAD_VAL22:%.*]] = insertvalue { ptr, i32 } [[LPAD_VAL]], i32 [[SEL21]], 1
+// CHECK-SANITIZE-TRAP-NEXT:    resume { ptr, i32 } [[LPAD_VAL22]]
+// CHECK-SANITIZE-TRAP:       terminate.lpad:
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP21:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-TRAP-NEXT:    catch ptr null
+// CHECK-SANITIZE-TRAP-NEXT:    [[TMP22:%.*]] = extractvalue { ptr, i32 } [[TMP21]], 0
+// CHECK-SANITIZE-TRAP-NEXT:    call void @__clang_call_terminate(ptr [[TMP22]]) #[[ATTR8]]
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable
+// CHECK-SANITIZE-TRAP:       unreachable:
+// CHECK-SANITIZE-TRAP-NEXT:    unreachable
+//
+void exception_escape_is_ok(int x) {
+  if (x == 2) {
+#line 100
+    will_throw();
+  }
+#line 200
+  will_not_throw();
+  if (x == 3) {
+#line 300
+    will_throw();
+  }
+  if (x == 4) {
+    try {
+#line 400
+      will_not_throw();
+#line 500
+      will_throw();
+    } catch (...) {
+#line 600
+      will_not_throw();
+#line 700
+      might_throw();
+#line 800
+      throw;
+    }
+  }
+  if (x == 5) {
+    try {
+#line 900
+      will_throw();
+    } catch (int x) {
+#line 1000
+      throw x;
+    }
+  }
+}
diff --git a/clang/test/CodeGenCXX/exception-escape-as-ub-cleanups.cpp b/clang/test/CodeGenCXX/exception-escape-as-ub-cleanups.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/CodeGenCXX/exception-escape-as-ub-cleanups.cpp
@@ -0,0 +1,776 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+// RUN: %clang_cc1                             -emit-llvm %s -o - -triple x86_64-linux-gnu              -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-NO-EXCEPTIONS
+// RUN: %clang_cc1                             -emit-llvm %s -o - -triple x86_64-linux-gnu -fexceptions -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-NOSANITIZE
+// RUN: %clang_cc1 -fsanitize=exception-escape -emit-llvm %s -o - -triple x86_64-linux-gnu -fexceptions -fcxx-exceptions | FileCheck %s --check-prefixes=CHECK-SANITIZE-NORECOVER
+
+void will_throw(int line = __builtin_LINE());
+void might_throw(int line = __builtin_LINE());
+void will_not_throw(int line = __builtin_LINE()) noexcept;
+
+struct S {
+  S(int line = __builtin_LINE());
+  ~S();
+};
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z30footgun_exception_escape_is_ubi
+// CHECK-NO-EXCEPTIONS-SAME: (i32 noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE3:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE7:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100) #[[ATTR4:[0-9]+]]
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z11might_throwi(i32 noundef 200) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END]]
+// CHECK-NO-EXCEPTIONS:       if.end:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 1
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then2:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]], i32 noundef 300)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z11might_throwi(i32 noundef 400)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END4]]
+// CHECK-NO-EXCEPTIONS:       if.end4:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP2]], 2
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END8:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then6:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE7]], i32 noundef 600) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 700) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE7]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END8]]
+// CHECK-NO-EXCEPTIONS:       if.end8:
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-NOSANITIZE: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-NOSANITIZE-LABEL: define {{[^@]+}}@_Z30footgun_exception_escape_is_ubi
+// CHECK-NOSANITIZE-SAME: (i32 noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-NOSANITIZE-NEXT:  entry:
+// CHECK-NOSANITIZE-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NOSANITIZE-NEXT:    [[STATE3:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NOSANITIZE-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[STATE9:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NOSANITIZE:       if.then:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100) #[[ATTR6:[0-9]+]]
+// CHECK-NOSANITIZE-NEXT:    call void @_Z11might_throwi(i32 noundef 200) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END]]
+// CHECK-NOSANITIZE:       if.end:
+// CHECK-NOSANITIZE-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 1
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END6:%.*]]
+// CHECK-NOSANITIZE:       if.then2:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]], i32 noundef 300)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z11might_throwi(i32 noundef 400)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT5:%.*]] unwind label [[LPAD4:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont5:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-NOSANITIZE:       lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP2:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP3:%.*]] = extractvalue { ptr, i32 } [[TMP2]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP3]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP2]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP4]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH:%.*]]
+// CHECK-NOSANITIZE:       lpad4:
+// CHECK-NOSANITIZE-NEXT:    [[TMP5:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP6:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP6]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP7:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP7]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH]]
+// CHECK-NOSANITIZE:       catch:
+// CHECK-NOSANITIZE-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP8:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    call void @__cxa_rethrow() #[[ATTR7:[0-9]+]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       try.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END6]]
+// CHECK-NOSANITIZE:       if.end6:
+// CHECK-NOSANITIZE-NEXT:    [[TMP9:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP7:%.*]] = icmp eq i32 [[TMP9]], 2
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP7]], label [[IF_THEN8:%.*]], label [[IF_END10:%.*]]
+// CHECK-NOSANITIZE:       if.then8:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE9]], i32 noundef 600) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    call void @_Z10will_throwi(i32 noundef 700) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE9]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END10]]
+// CHECK-NOSANITIZE:       if.end10:
+// CHECK-NOSANITIZE-NEXT:    ret void
+//
+// CHECK-SANITIZE-NORECOVER: Function Attrs: mustprogress noinline nounwind optnone willreturn memory(read)
+// CHECK-SANITIZE-NORECOVER-LABEL: define {{[^@]+}}@_Z30footgun_exception_escape_is_ubi
+// CHECK-SANITIZE-NORECOVER-SAME: (i32 noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-NORECOVER-NEXT:  entry:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[INVOKE_SRCLOC:%.*]] = alloca { ptr, i32, i32 }, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP:%.*]] = alloca { ptr, i32, i32 }, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE4:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE11:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 100, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 200, i32 5 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 200)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT1:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont1:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR7:[0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-NORECOVER:       handler.exception_escape:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } [[CURR_INVOKE_SRCLOC:%.*]], ptr [[TMP]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP1:%.*]] = ptrtoint ptr [[TMP]] to i64, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP2:%.*]] = ptrtoint ptr [[EXN15:%.*]] to i64, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__ubsan_handle_exception_escape(i64 [[TMP1]], i64 [[TMP2]]) #[[ATTR8:[0-9]+]], !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER:       cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER:       if.end:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP3:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[TMP3]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END8:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then3:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 300, i32 9 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]], i32 noundef 300)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT5:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont5:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 400, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 400)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont7:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP4:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP5:%.*]] = extractvalue { ptr, i32 } [[TMP4]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP5]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP6:%.*]] = extractvalue { ptr, i32 } [[TMP4]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP6]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad6:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP7:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP8:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP8]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP7]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP9]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH]]
+// CHECK-SANITIZE-NORECOVER:       catch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP10:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 500, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_rethrow() #[[ATTR9:[0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       try.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END8]]
+// CHECK-SANITIZE-NORECOVER:       if.end8:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP11:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP9:%.*]] = icmp eq i32 [[TMP11]], 2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP9]], label [[IF_THEN10:%.*]], label [[IF_END14:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then10:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 600, i32 7 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE11]], i32 noundef 600)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT12:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont12:
+// CHECK-SANITIZE-NORECOVER-NEXT:    store { ptr, i32, i32 } { ptr @.src, i32 700, i32 5 }, ptr [[INVOKE_SRCLOC]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 700)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[EXCEPTION_ESCAPE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont13:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE11]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END14]]
+// CHECK-SANITIZE-NORECOVER:       if.end14:
+// CHECK-SANITIZE-NORECOVER-NEXT:    ret void
+// CHECK-SANITIZE-NORECOVER:       unreachable:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+// CHECK-SANITIZE-NORECOVER:       exception-escape.sanitization:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN15]] = load ptr, ptr [[EXN_SLOT]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CURR_INVOKE_SRCLOC]] = load { ptr, i32, i32 }, ptr [[INVOKE_SRCLOC]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 false, label [[CONT:%.*]], label [[HANDLER_EXCEPTION_ESCAPE:%.*]], !prof [[PROF3:![0-9]+]], !nosanitize !2
+// CHECK-SANITIZE-NORECOVER:       exception-escape.lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP12:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP13:%.*]] = extractvalue { ptr, i32 } [[TMP12]], 0, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP13]], ptr [[EXN_SLOT]], align 8, !nosanitize !2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EXCEPTION_ESCAPE_SANITIZATION:%.*]], !nosanitize !2
+//
+void __attribute__((pure)) footgun_exception_escape_is_ub(int x) {
+  if(x == 0) {
+#line 100
+    S state;
+#line 200
+    might_throw();
+  }
+  if(x == 1) {
+    try {
+#line 300
+      S state;
+#line 400
+      might_throw();
+    } catch (...) {
+#line 500
+      throw;
+    }
+  }
+  if(x == 2) {
+#line 600
+    S state;
+#line 700
+    will_throw();
+  }
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z39exception_escape_is_program_terminationi
+// CHECK-NO-EXCEPTIONS-SAME: (i32 noundef [[X:%.*]]) #[[ATTR3:[0-9]+]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE3:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE7:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z11might_throwi(i32 noundef 200)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END]]
+// CHECK-NO-EXCEPTIONS:       if.end:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 1
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then2:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]], i32 noundef 300)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z11might_throwi(i32 noundef 400)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END4]]
+// CHECK-NO-EXCEPTIONS:       if.end4:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP2]], 2
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END8:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then6:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE7]], i32 noundef 600)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 700)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE7]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END8]]
+// CHECK-NO-EXCEPTIONS:       if.end8:
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-NOSANITIZE: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NOSANITIZE-LABEL: define {{[^@]+}}@_Z39exception_escape_is_program_terminationi
+// CHECK-NOSANITIZE-SAME: (i32 noundef [[X:%.*]]) #[[ATTR3:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-NOSANITIZE-NEXT:  entry:
+// CHECK-NOSANITIZE-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NOSANITIZE-NEXT:    [[STATE4:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NOSANITIZE-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[STATE11:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NOSANITIZE:       if.then:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z11might_throwi(i32 noundef 200)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT1:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       invoke.cont1:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END]]
+// CHECK-NOSANITIZE:       if.end:
+// CHECK-NOSANITIZE-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[TMP1]], 1
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END8:%.*]]
+// CHECK-NOSANITIZE:       if.then3:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]], i32 noundef 300)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT5:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont5:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z11might_throwi(i32 noundef 400)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont7:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-NOSANITIZE:       lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP2:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP3:%.*]] = extractvalue { ptr, i32 } [[TMP2]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP3]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP2]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP4]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH:%.*]]
+// CHECK-NOSANITIZE:       lpad6:
+// CHECK-NOSANITIZE-NEXT:    [[TMP5:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP6:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP6]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP7:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP7]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH]]
+// CHECK-NOSANITIZE:       catch:
+// CHECK-NOSANITIZE-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP8:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_rethrow() #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       try.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END8]]
+// CHECK-NOSANITIZE:       if.end8:
+// CHECK-NOSANITIZE-NEXT:    [[TMP9:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP9:%.*]] = icmp eq i32 [[TMP9]], 2
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP9]], label [[IF_THEN10:%.*]], label [[IF_END14:%.*]]
+// CHECK-NOSANITIZE:       if.then10:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE11]], i32 noundef 600)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT12:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       invoke.cont12:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 700)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-NOSANITIZE:       invoke.cont13:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE11]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END14]]
+// CHECK-NOSANITIZE:       if.end14:
+// CHECK-NOSANITIZE-NEXT:    ret void
+// CHECK-NOSANITIZE:       terminate.lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP10:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP11:%.*]] = extractvalue { ptr, i32 } [[TMP10]], 0
+// CHECK-NOSANITIZE-NEXT:    call void @__clang_call_terminate(ptr [[TMP11]]) #[[ATTR8:[0-9]+]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       unreachable:
+// CHECK-NOSANITIZE-NEXT:    unreachable
+//
+// CHECK-SANITIZE-NORECOVER: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-SANITIZE-NORECOVER-LABEL: define {{[^@]+}}@_Z39exception_escape_is_program_terminationi
+// CHECK-SANITIZE-NORECOVER-SAME: (i32 noundef [[X:%.*]]) #[[ATTR4:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-NORECOVER-NEXT:  entry:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE4:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE11:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 200)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT1:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont1:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-NORECOVER:       if.end:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[TMP1]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END8:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then3:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]], i32 noundef 300)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT5:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont5:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 400)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont7:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP2:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP3:%.*]] = extractvalue { ptr, i32 } [[TMP2]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP3]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP4:%.*]] = extractvalue { ptr, i32 } [[TMP2]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP4]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad6:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP5:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP6:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP6]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP7:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP7]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE4]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH]]
+// CHECK-SANITIZE-NORECOVER:       catch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP8:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_rethrow() #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       try.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END8]]
+// CHECK-SANITIZE-NORECOVER:       if.end8:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP9:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP9:%.*]] = icmp eq i32 [[TMP9]], 2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP9]], label [[IF_THEN10:%.*]], label [[IF_END14:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then10:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE11]], i32 noundef 600)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT12:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont12:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 700)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT13:%.*]] unwind label [[TERMINATE_LPAD]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont13:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE11]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END14]]
+// CHECK-SANITIZE-NORECOVER:       if.end14:
+// CHECK-SANITIZE-NORECOVER-NEXT:    ret void
+// CHECK-SANITIZE-NORECOVER:       terminate.lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP10:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP11:%.*]] = extractvalue { ptr, i32 } [[TMP10]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__clang_call_terminate(ptr [[TMP11]]) #[[ATTR8]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+// CHECK-SANITIZE-NORECOVER:       unreachable:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+//
+void exception_escape_is_program_termination(int x) noexcept {
+  if(x == 0) {
+#line 100
+    S state;
+#line 200
+    might_throw();
+  }
+  if(x == 1) {
+    try {
+#line 300
+      S state;
+#line 400
+      might_throw();
+    } catch (...) {
+#line 500
+      throw;
+    }
+  }
+  if(x == 2) {
+#line 600
+    S state;
+#line 700
+    will_throw();
+  }
+}
+
+// CHECK-NO-EXCEPTIONS: Function Attrs: mustprogress noinline nounwind optnone
+// CHECK-NO-EXCEPTIONS-LABEL: define {{[^@]+}}@_Z22exception_escape_is_oki
+// CHECK-NO-EXCEPTIONS-SAME: (i32 noundef [[X:%.*]]) #[[ATTR3]] {
+// CHECK-NO-EXCEPTIONS-NEXT:  entry:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE3:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    [[STATE7:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NO-EXCEPTIONS-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z11might_throwi(i32 noundef 200)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END]]
+// CHECK-NO-EXCEPTIONS:       if.end:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP1]], 1
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END4:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then2:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]], i32 noundef 300)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z11might_throwi(i32 noundef 400)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END4]]
+// CHECK-NO-EXCEPTIONS:       if.end4:
+// CHECK-NO-EXCEPTIONS-NEXT:    [[TMP2:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NO-EXCEPTIONS-NEXT:    [[CMP5:%.*]] = icmp eq i32 [[TMP2]], 2
+// CHECK-NO-EXCEPTIONS-NEXT:    br i1 [[CMP5]], label [[IF_THEN6:%.*]], label [[IF_END8:%.*]]
+// CHECK-NO-EXCEPTIONS:       if.then6:
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE7]], i32 noundef 600)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_Z10will_throwi(i32 noundef 700)
+// CHECK-NO-EXCEPTIONS-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE7]]) #[[ATTR4]]
+// CHECK-NO-EXCEPTIONS-NEXT:    br label [[IF_END8]]
+// CHECK-NO-EXCEPTIONS:       if.end8:
+// CHECK-NO-EXCEPTIONS-NEXT:    ret void
+//
+// CHECK-NOSANITIZE: Function Attrs: mustprogress noinline optnone
+// CHECK-NOSANITIZE-LABEL: define {{[^@]+}}@_Z22exception_escape_is_oki
+// CHECK-NOSANITIZE-SAME: (i32 noundef [[X:%.*]]) #[[ATTR5:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-NOSANITIZE-NEXT:  entry:
+// CHECK-NOSANITIZE-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NOSANITIZE-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-NOSANITIZE-NEXT:    [[STATE3:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NOSANITIZE-NEXT:    [[STATE13:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-NOSANITIZE:       if.then:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100)
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z11might_throwi(i32 noundef 200)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END]]
+// CHECK-NOSANITIZE:       lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP1:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    cleanup
+// CHECK-NOSANITIZE-NEXT:    [[TMP2:%.*]] = extractvalue { ptr, i32 } [[TMP1]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP2]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP3:%.*]] = extractvalue { ptr, i32 } [[TMP1]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP3]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[EH_RESUME:%.*]]
+// CHECK-NOSANITIZE:       if.end:
+// CHECK-NOSANITIZE-NEXT:    [[TMP4:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP4]], 1
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END10:%.*]]
+// CHECK-NOSANITIZE:       if.then2:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]], i32 noundef 300)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT5:%.*]] unwind label [[LPAD4:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont5:
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z11might_throwi(i32 noundef 400)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont7:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-NOSANITIZE:       lpad4:
+// CHECK-NOSANITIZE-NEXT:    [[TMP5:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP6:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP6]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP7:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP7]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH:%.*]]
+// CHECK-NOSANITIZE:       lpad6:
+// CHECK-NOSANITIZE-NEXT:    [[TMP8:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP9]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP10:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP10]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[CATCH]]
+// CHECK-NOSANITIZE:       catch:
+// CHECK-NOSANITIZE-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP11:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_rethrow() #[[ATTR7]]
+// CHECK-NOSANITIZE-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD8:%.*]]
+// CHECK-NOSANITIZE:       lpad8:
+// CHECK-NOSANITIZE-NEXT:    [[TMP12:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    cleanup
+// CHECK-NOSANITIZE-NEXT:    [[TMP13:%.*]] = extractvalue { ptr, i32 } [[TMP12]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP13]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP14:%.*]] = extractvalue { ptr, i32 } [[TMP12]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP14]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    invoke void @__cxa_end_catch()
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT9:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont9:
+// CHECK-NOSANITIZE-NEXT:    br label [[EH_RESUME]]
+// CHECK-NOSANITIZE:       try.cont:
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END10]]
+// CHECK-NOSANITIZE:       if.end10:
+// CHECK-NOSANITIZE-NEXT:    [[TMP15:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[CMP11:%.*]] = icmp eq i32 [[TMP15]], 2
+// CHECK-NOSANITIZE-NEXT:    br i1 [[CMP11]], label [[IF_THEN12:%.*]], label [[IF_END16:%.*]]
+// CHECK-NOSANITIZE:       if.then12:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE13]], i32 noundef 600)
+// CHECK-NOSANITIZE-NEXT:    invoke void @_Z10will_throwi(i32 noundef 700)
+// CHECK-NOSANITIZE-NEXT:    to label [[INVOKE_CONT15:%.*]] unwind label [[LPAD14:%.*]]
+// CHECK-NOSANITIZE:       invoke.cont15:
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE13]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[IF_END16]]
+// CHECK-NOSANITIZE:       lpad14:
+// CHECK-NOSANITIZE-NEXT:    [[TMP16:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    cleanup
+// CHECK-NOSANITIZE-NEXT:    [[TMP17:%.*]] = extractvalue { ptr, i32 } [[TMP16]], 0
+// CHECK-NOSANITIZE-NEXT:    store ptr [[TMP17]], ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[TMP18:%.*]] = extractvalue { ptr, i32 } [[TMP16]], 1
+// CHECK-NOSANITIZE-NEXT:    store i32 [[TMP18]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE13]]) #[[ATTR6]]
+// CHECK-NOSANITIZE-NEXT:    br label [[EH_RESUME]]
+// CHECK-NOSANITIZE:       if.end16:
+// CHECK-NOSANITIZE-NEXT:    ret void
+// CHECK-NOSANITIZE:       eh.resume:
+// CHECK-NOSANITIZE-NEXT:    [[EXN17:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-NOSANITIZE-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-NOSANITIZE-NEXT:    [[LPAD_VAL:%.*]] = insertvalue { ptr, i32 } undef, ptr [[EXN17]], 0
+// CHECK-NOSANITIZE-NEXT:    [[LPAD_VAL18:%.*]] = insertvalue { ptr, i32 } [[LPAD_VAL]], i32 [[SEL]], 1
+// CHECK-NOSANITIZE-NEXT:    resume { ptr, i32 } [[LPAD_VAL18]]
+// CHECK-NOSANITIZE:       terminate.lpad:
+// CHECK-NOSANITIZE-NEXT:    [[TMP19:%.*]] = landingpad { ptr, i32 }
+// CHECK-NOSANITIZE-NEXT:    catch ptr null
+// CHECK-NOSANITIZE-NEXT:    [[TMP20:%.*]] = extractvalue { ptr, i32 } [[TMP19]], 0
+// CHECK-NOSANITIZE-NEXT:    call void @__clang_call_terminate(ptr [[TMP20]]) #[[ATTR8]]
+// CHECK-NOSANITIZE-NEXT:    unreachable
+// CHECK-NOSANITIZE:       unreachable:
+// CHECK-NOSANITIZE-NEXT:    unreachable
+//
+// CHECK-SANITIZE-NORECOVER: Function Attrs: mustprogress noinline optnone
+// CHECK-SANITIZE-NORECOVER-LABEL: define {{[^@]+}}@_Z22exception_escape_is_oki
+// CHECK-SANITIZE-NORECOVER-SAME: (i32 noundef [[X:%.*]]) #[[ATTR6:[0-9]+]] personality ptr @__gxx_personality_v0 {
+// CHECK-SANITIZE-NORECOVER-NEXT:  entry:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[X_ADDR:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN_SLOT:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EHSELECTOR_SLOT:%.*]] = alloca i32, align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE3:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[STATE13:%.*]] = alloca [[STRUCT_S]], align 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[X]], ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP0:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]], i32 noundef 100)
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 200)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END]]
+// CHECK-SANITIZE-NORECOVER:       lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP1:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    cleanup
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP2:%.*]] = extractvalue { ptr, i32 } [[TMP1]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP2]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP3:%.*]] = extractvalue { ptr, i32 } [[TMP1]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP3]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EH_RESUME:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.end:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP4:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[TMP4]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP1]], label [[IF_THEN2:%.*]], label [[IF_END10:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then2:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]], i32 noundef 300)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT5:%.*]] unwind label [[LPAD4:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont5:
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z11might_throwi(i32 noundef 400)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT7:%.*]] unwind label [[LPAD6:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont7:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[TRY_CONT:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad4:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP5:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP6:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP6]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP7:%.*]] = extractvalue { ptr, i32 } [[TMP5]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP7]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad6:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP8:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP9:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP9]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP10:%.*]] = extractvalue { ptr, i32 } [[TMP8]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP10]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE3]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[CATCH]]
+// CHECK-SANITIZE-NORECOVER:       catch:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP11:%.*]] = call ptr @__cxa_begin_catch(ptr [[EXN]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_rethrow() #[[ATTR9]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[UNREACHABLE:%.*]] unwind label [[LPAD8:%.*]]
+// CHECK-SANITIZE-NORECOVER:       lpad8:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP12:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    cleanup
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP13:%.*]] = extractvalue { ptr, i32 } [[TMP12]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP13]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP14:%.*]] = extractvalue { ptr, i32 } [[TMP12]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP14]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @__cxa_end_catch()
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT9:%.*]] unwind label [[TERMINATE_LPAD:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont9:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EH_RESUME]]
+// CHECK-SANITIZE-NORECOVER:       try.cont:
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END10]]
+// CHECK-SANITIZE-NORECOVER:       if.end10:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP15:%.*]] = load i32, ptr [[X_ADDR]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[CMP11:%.*]] = icmp eq i32 [[TMP15]], 2
+// CHECK-SANITIZE-NORECOVER-NEXT:    br i1 [[CMP11]], label [[IF_THEN12:%.*]], label [[IF_END16:%.*]]
+// CHECK-SANITIZE-NORECOVER:       if.then12:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SC1Ei(ptr noundef nonnull align 1 dereferenceable(1) [[STATE13]], i32 noundef 600)
+// CHECK-SANITIZE-NORECOVER-NEXT:    invoke void @_Z10will_throwi(i32 noundef 700)
+// CHECK-SANITIZE-NORECOVER-NEXT:    to label [[INVOKE_CONT15:%.*]] unwind label [[LPAD14:%.*]]
+// CHECK-SANITIZE-NORECOVER:       invoke.cont15:
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE13]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[IF_END16]]
+// CHECK-SANITIZE-NORECOVER:       lpad14:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP16:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    cleanup
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP17:%.*]] = extractvalue { ptr, i32 } [[TMP16]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    store ptr [[TMP17]], ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP18:%.*]] = extractvalue { ptr, i32 } [[TMP16]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    store i32 [[TMP18]], ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @_ZN1SD1Ev(ptr noundef nonnull align 1 dereferenceable(1) [[STATE13]]) #[[ATTR7]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    br label [[EH_RESUME]]
+// CHECK-SANITIZE-NORECOVER:       if.end16:
+// CHECK-SANITIZE-NORECOVER-NEXT:    ret void
+// CHECK-SANITIZE-NORECOVER:       eh.resume:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[EXN17:%.*]] = load ptr, ptr [[EXN_SLOT]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[SEL:%.*]] = load i32, ptr [[EHSELECTOR_SLOT]], align 4
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[LPAD_VAL:%.*]] = insertvalue { ptr, i32 } undef, ptr [[EXN17]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[LPAD_VAL18:%.*]] = insertvalue { ptr, i32 } [[LPAD_VAL]], i32 [[SEL]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT:    resume { ptr, i32 } [[LPAD_VAL18]]
+// CHECK-SANITIZE-NORECOVER:       terminate.lpad:
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP19:%.*]] = landingpad { ptr, i32 }
+// CHECK-SANITIZE-NORECOVER-NEXT:    catch ptr null
+// CHECK-SANITIZE-NORECOVER-NEXT:    [[TMP20:%.*]] = extractvalue { ptr, i32 } [[TMP19]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT:    call void @__clang_call_terminate(ptr [[TMP20]]) #[[ATTR8]]
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+// CHECK-SANITIZE-NORECOVER:       unreachable:
+// CHECK-SANITIZE-NORECOVER-NEXT:    unreachable
+//
+void exception_escape_is_ok(int x) {
+  if(x == 0) {
+#line 100
+    S state;
+#line 200
+    might_throw();
+  }
+  if(x == 1) {
+    try {
+#line 300
+      S state;
+#line 400
+      might_throw();
+    } catch (...) {
+#line 500
+      throw;
+    }
+  }
+  if(x == 2) {
+#line 600
+    S state;
+#line 700
+    will_throw();
+  }
+}
diff --git a/clang/test/Driver/fsanitize.c b/clang/test/Driver/fsanitize.c
--- a/clang/test/Driver/fsanitize.c
+++ b/clang/test/Driver/fsanitize.c
@@ -5,15 +5,15 @@
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize-undefined-trap-on-error -fsanitize=undefined-trap %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize-trap -fsanitize=undefined-trap %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP
 // CHECK-UNDEFINED-TRAP-NOT: -fsanitize-recover
-// CHECK-UNDEFINED-TRAP: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|function),?){18}"}}
-// CHECK-UNDEFINED-TRAP: "-fsanitize-trap=alignment,array-bounds,bool,builtin,enum,float-cast-overflow,function,integer-divide-by-zero,nonnull-attribute,null,pointer-overflow,return,returns-nonnull-attribute,shift-base,shift-exponent,signed-integer-overflow,unreachable,vla-bound"
-// CHECK-UNDEFINED-TRAP2: "-fsanitize-trap=alignment,array-bounds,bool,builtin,enum,float-cast-overflow,function,integer-divide-by-zero,nonnull-attribute,null,pointer-overflow,return,returns-nonnull-attribute,shift-base,shift-exponent,unreachable,vla-bound"
+// CHECK-UNDEFINED-TRAP: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|function|exception-escape),?){19}"}}
+// CHECK-UNDEFINED-TRAP: "-fsanitize-trap=alignment,array-bounds,bool,builtin,enum,float-cast-overflow,function,integer-divide-by-zero,nonnull-attribute,null,pointer-overflow,return,returns-nonnull-attribute,shift-base,shift-exponent,signed-integer-overflow,unreachable,vla-bound,exception-escape"
+// CHECK-UNDEFINED-TRAP2: "-fsanitize-trap=alignment,array-bounds,bool,builtin,enum,float-cast-overflow,function,integer-divide-by-zero,nonnull-attribute,null,pointer-overflow,return,returns-nonnull-attribute,shift-base,shift-exponent,unreachable,vla-bound,exception-escape"
 
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED
-// CHECK-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|function|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|vptr|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute),?){19}"}}
+// CHECK-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|function|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|vptr|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|exception-escape),?){20}"}}
 
 // RUN: %clang --target=x86_64-apple-darwin10 -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-DARWIN
-// CHECK-UNDEFINED-DARWIN: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|function|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute),?){18}"}}
+// CHECK-UNDEFINED-DARWIN: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|function|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|exception-escape),?){19}"}}
 
 // RUN: %clang --target=i386-pc-win32 -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefixes=CHECK-UNDEFINED-WIN32,CHECK-UNDEFINED-MSVC
 // RUN: %clang --target=i386-pc-win32 -fsanitize=undefined -x c++ %s -### 2>&1 | FileCheck %s --check-prefixes=CHECK-UNDEFINED-WIN32,CHECK-UNDEFINED-WIN-CXX,CHECK-UNDEFINED-MSVC
@@ -24,8 +24,8 @@
 // CHECK-UNDEFINED-WIN64: "--dependent-lib={{[^"]*}}ubsan_standalone{{(-x86_64)?}}.lib"
 // CHECK-UNDEFINED-WIN64-MINGW: "--dependent-lib={{[^"]*}}libclang_rt.ubsan_standalone{{(-x86_64)?}}.a"
 // CHECK-UNDEFINED-WIN-CXX: "--dependent-lib={{[^"]*}}ubsan_standalone_cxx{{[^"]*}}.lib"
-// CHECK-UNDEFINED-MSVC-SAME: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute),?){17}"}}
-// CHECK-UNDEFINED-WIN64-MINGW-SAME: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|vptr),?){18}"}}
+// CHECK-UNDEFINED-MSVC-SAME: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|exception-escape),?){18}"}}
+// CHECK-UNDEFINED-WIN64-MINGW-SAME: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|vptr|exception-escape),?){19}"}}
 
 // RUN: %clang --target=i386-pc-win32 -fsanitize-coverage=bb %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-COVERAGE-WIN32
 // CHECK-COVERAGE-WIN32: "--dependent-lib={{[^"]*}}ubsan_standalone{{(-i386)?}}.lib"
@@ -90,7 +90,7 @@
 // CHECK-FNO-SANITIZE-ALL: "-fsanitize=thread"
 
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=thread,undefined -fno-sanitize=thread -fno-sanitize=float-cast-overflow,vptr,bool,builtin,enum %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-PARTIAL-UNDEFINED
-// CHECK-PARTIAL-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|function|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|array-bounds|returns-nonnull-attribute|nonnull-attribute),?){14}"}}
+// CHECK-PARTIAL-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|function|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|array-bounds|returns-nonnull-attribute|nonnull-attribute|exception-escape),?){15}"}}
 
 // RUN: %clang -fsanitize=shift -fno-sanitize=shift-base %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FSANITIZE-SHIFT-PARTIAL
 // CHECK-FSANITIZE-SHIFT-PARTIAL: "-fsanitize=shift-exponent"
@@ -823,7 +823,7 @@
 // CHECK-TSAN-MINIMAL: error: invalid argument '-fsanitize-minimal-runtime' not allowed with '-fsanitize=thread'
 
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN-MINIMAL
-// CHECK-UBSAN-MINIMAL: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute),?){17}"}}
+// CHECK-UBSAN-MINIMAL: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|exception-escape),?){18}"}}
 // CHECK-UBSAN-MINIMAL: "-fsanitize-minimal-runtime"
 
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=integer -fsanitize-trap=integer %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INTSAN-TRAP
diff --git a/compiler-rt/lib/ubsan/ubsan_checks.inc b/compiler-rt/lib/ubsan/ubsan_checks.inc
--- a/compiler-rt/lib/ubsan/ubsan_checks.inc
+++ b/compiler-rt/lib/ubsan/ubsan_checks.inc
@@ -69,3 +69,4 @@
             "nullability-arg")
 UBSAN_CHECK(DynamicTypeMismatch, "dynamic-type-mismatch", "vptr")
 UBSAN_CHECK(CFIBadType, "cfi-bad-type", "cfi")
+UBSAN_CHECK(ExceptionEscape, "exception-escape", "exception-escape")
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers.h b/compiler-rt/lib/ubsan/ubsan_handlers.h
--- a/compiler-rt/lib/ubsan/ubsan_handlers.h
+++ b/compiler-rt/lib/ubsan/ubsan_handlers.h
@@ -99,6 +99,13 @@
 /// \brief Handle reaching the end of a value-returning function.
 UNRECOVERABLE(missing_return, UnreachableData *Data)
 
+struct ExceptionEscapeData {
+  SourceLocation Loc;
+};
+
+/// \brief Handle exception escaping out of C++ `noexcept` function.
+UNRECOVERABLE(exception_escape, ExceptionEscapeData *Data, ValueHandle Exn)
+
 struct VLABoundData {
   SourceLocation Loc;
   const TypeDescriptor &Type;
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers.cpp b/compiler-rt/lib/ubsan/ubsan_handlers.cpp
--- a/compiler-rt/lib/ubsan/ubsan_handlers.cpp
+++ b/compiler-rt/lib/ubsan/ubsan_handlers.cpp
@@ -433,6 +433,17 @@
   Die();
 }
 
+void __ubsan::__ubsan_handle_exception_escape(ExceptionEscapeData *Data,
+                                              ValueHandle Exn) {
+  GET_REPORT_OPTIONS(true);
+  ErrorType ET = ErrorType::ExceptionEscape;
+  ScopedReport R(Opts, Data->Loc, ET);
+  Diag(Data->Loc, DL_Error, ET,
+       "exception escapes out of function that should not throw exception");
+  // FIXME: can we do anything useful with the \p Exn?
+  Die();
+}
+
 static void handleVLABoundNotPositive(VLABoundData *Data, ValueHandle Bound,
                                       ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
diff --git a/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp b/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp
--- a/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp
+++ b/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp
@@ -141,3 +141,4 @@
 HANDLER(nullability_return, "nullability-return")
 HANDLER(pointer_overflow, "pointer-overflow")
 HANDLER(cfi_check_fail, "cfi-check-fail")
+HANDLER(exception_escape, "exception-escape")
diff --git a/compiler-rt/test/ubsan/TestCases/Misc/exception-escape.cpp b/compiler-rt/test/ubsan/TestCases/Misc/exception-escape.cpp
new file mode 100644
--- /dev/null
+++ b/compiler-rt/test/ubsan/TestCases/Misc/exception-escape.cpp
@@ -0,0 +1,104 @@
+// RUN: %clangxx -fsanitize=exception-escape %s -O3 -o %t
+// RUN:     %run %t 2>&1 | FileCheck %s --implicit-check-not="error:" --check-prefixes=CHECK-ALL,CHECK-ONE
+// RUN: not %run %t 2 2>&1 | FileCheck %s --implicit-check-not="error:" --check-prefixes=CHECK-ALL,CHECK-TWO
+// RUN: not %run %t 2 3 2>&1 | FileCheck %s --implicit-check-not="error:" --check-prefixes=CHECK-ALL,CHECK-THREE
+// RUN:     %run %t 2 3 4 2>&1 | FileCheck %s --implicit-check-not="error:" --check-prefixes=CHECK-ALL,CHECK-FOUR
+// RUN: not %run %t 2 3 4 5 2>&1 | FileCheck %s --implicit-check-not="error:" --check-prefixes=CHECK-ALL,CHECK-FIVE
+// RUN: not %run %t 2 3 4 5 6 2>&1 | FileCheck %s --implicit-check-not="error:" --check-prefixes=CHECK-ALL,CHECK-SIX
+// RUN: not %run %t 2 3 4 5 6 6 2>&1 | FileCheck %s --implicit-check-not="error:" --check-prefixes=CHECK-ALL,CHECK-SEVEN
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void thrower() { throw 0; }
+
+void maybe_throws() {}
+
+void nonthrower() noexcept {}
+
+// pure functions are generally side-effect free,
+// so we need to be smart to defeat optimizer
+// from completely dropping the call to the function...
+
+void *__attribute__((pure)) footgun(int x) {
+  if (x == 2)
+#line 100
+    thrower();
+
+  if (x == 3)
+#line 200
+    thrower();
+
+  nonthrower();
+
+  if (x == 4) {
+    try {
+#line 300
+      thrower();
+    } catch (...) {
+    }
+  }
+
+  if (x == 5) {
+    try {
+#line 400
+      thrower();
+    } catch (...) {
+#line 500
+      throw;
+    }
+  }
+
+  if (x == 6) {
+    try {
+#line 600
+      thrower();
+    } catch (...) {
+#line 700
+      maybe_throws();
+#line 800
+      throw;
+    }
+  }
+
+  if (x == 7) {
+    try {
+#line 900
+      thrower();
+    } catch (...) {
+#line 1000
+      thrower();
+#line 1100
+      throw;
+    }
+  }
+
+  fprintf(stderr, "SUCCESS\n"); // Should be here, not in `main()`.
+  return malloc(1);
+}
+
+// CHECK-ALL: TEST
+
+// CHECK-ONE: SUCCESS
+// CHECK-TWO: exception-escape.cpp:100:5: runtime error: exception escapes out of function that should not throw exception
+// CHECK-THREE: exception-escape.cpp:200:5: runtime error: exception escapes out of function that should not throw exception
+// CHECK-FOUR: SUCCESS
+// CHECK-FIVE: exception-escape.cpp:400:7: runtime error: exception escapes out of function that should not throw exception
+// CHECK-SIX: exception-escape.cpp:600:7: runtime error: exception escapes out of function that should not throw exception
+// CHECK-SEVEN: exception-escape.cpp:1000:7: runtime error: exception escapes out of function that should not throw exception
+
+int main(int argc, char **argv) {
+  bool status = 0;
+  void *mem = nullptr;
+
+  fprintf(stderr, "TEST\n");
+
+  try {
+    mem = footgun(argc);
+    status = !(mem != 0);
+  } catch (...) {
+  }
+
+  fprintf(stderr, "escaping: %p\n", mem);
+  return status;
+}
diff --git a/compiler-rt/test/ubsan_minimal/TestCases/exception-escape.cpp b/compiler-rt/test/ubsan_minimal/TestCases/exception-escape.cpp
new file mode 100644
--- /dev/null
+++ b/compiler-rt/test/ubsan_minimal/TestCases/exception-escape.cpp
@@ -0,0 +1,48 @@
+// RUN: %clangxx -fsanitize=exception-escape %s -O3 -o %t
+// RUN: %run %t 2>&1 | FileCheck %s --implicit-check-not="exception-escape" --check-prefixes=CHECK-ALL,CHECK-ONE
+// RUN: not --crash %run %t a 2>&1 | FileCheck %s --implicit-check-not="exception-escape" --check-prefixes=CHECK-ALL,CHECK-TWO
+// RUN: not --crash %run %t a b 2>&1 | FileCheck %s --implicit-check-not="exception-escape" --check-prefixes=CHECK-ALL,CHECK-THREE
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void thrower() { throw 0; }
+
+void nonthrower() noexcept {}
+
+// pure functions are generally side-effect free,
+// so we need to be smart to defeat optimizer
+// from completely dropping the call to the function...
+
+void *__attribute__((pure)) footgun(int x) {
+  if (x == 2)
+    thrower();
+  if (x == 3)
+    thrower();
+  nonthrower();
+  fprintf(stderr, "SUCCESS\n");
+  return malloc(1);
+}
+
+// CHECK-ALL: TEST
+
+// CHECK-ONE: SUCCESS
+// CHECK-TWO: exception-escape
+// CHECK-THREE: exception-escape
+
+int main(int argc, char **argv) {
+  bool status = 0;
+  void *mem = nullptr;
+
+  fprintf(stderr, "TEST\n");
+
+  try {
+    mem = footgun(argc);
+    status = !(mem != 0);
+  } catch (...) {
+  }
+
+  fprintf(stderr, "escaping: %p\n", mem);
+  free(mem);
+  return status;
+}