[CodeGen] Emit MSVC funclet IR for Obj-C exceptions

[smeenai]

Summary

We're implementing funclet-compatible code generation for Obj-C
exceptions when using the MSVC ABI. The idea is that the Obj-C runtime
will wrap Obj-C exceptions inside C++ exceptions, which allows for
interoperability with C++ exceptions (for Obj-C++) and zero-cost
exceptions. This is the approach taken by e.g. WinObjC, and I believe it
to be the best approach for Obj-C exceptions in the MSVC ABI.

This change implements emitting the actual funclet-compatible IR. The
generic exceptions codegen already takes care of emitting the proper
catch dispatch structures, but we need to ensure proper handling of
catch parameters and scoping (emitting the catchret). Finally blocks are
handled quite differently from Itanium; they're expected to be outlined
by the frontend, which limits some control flow possibilities but also
greatly simplifies their codegen. See r334251 for further discussion of
why frontend outlining is used.

Worked on with Saleem Abdulrasool <[e-mail]>.

[smeenai]

@rnk remember how I was asking you about inlining into catchpads on IRC a few days back? It was in relation to this change.

If I have a file finally1.m:

void f(void);
void g() {
  @try {
    f();
  } @finally {
    f();
  }
}

and compile it with:

clang -cc1 -triple i686-windows-msvc -fobjc-runtime=ios-6.0 -fexceptions -fobjc-exceptions -Os -emit-llvm -o - finally1.m

the @finally calls out to the captured statement instead of inlining it:

finally.catchall:                                 ; preds = %catch.dispatch
  %1 = catchpad within %0 [i8* null, i32 64, i8* null]
  call fastcc void @__captured_stmt() [ "funclet"(token %1) ]
  call void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #3 [ "funclet"(token %1) ]
  unreachable

If I add an outer try-catch scope, as in finally2.m:

void f(void);
void g() {
  @try {
    @try {
      f();
    } @finally {
      f();
    }
  } @catch (...) {
  }
}

and run the same compilation command:

clang -cc1 -triple i686-windows-msvc -fobjc-runtime=ios-6.0 -fexceptions -fobjc-exceptions -Os -emit-llvm -o - finally2.m

the @finally inlines the captured statement:

finally.catchall:                                 ; preds = %catch.dispatch
  %2 = catchpad within %0 [i8* null, i32 64, i8* null]
  invoke void @f() #2 [ "funclet"(token %2) ]
          to label %invoke.cont1 unwind label %catch.dispatch4

invoke.cont1:                                     ; preds = %finally.catchall
  invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #3 [ "funclet"(token %2) ]
          to label %unreachable unwind label %catch.dispatch4

Any idea why we would see inlining in one case and not the other? i686 vs. x86-64 doesn't make any difference, and neither does -Os vs. -O1 vs. -O2.

[rnk]

In D47988#1127432, @smeenai wrote:

Any idea why we would see inlining in one case and not the other? i686 vs. x86-64 doesn't make any difference, and neither does -Os vs. -O1 vs. -O2.

My theory is that the inliner is attempting to avoid inlining on cold codepaths that are post-dominated by unreachable. When you put an outer try around it, the function may continue by unwinding, so the inline cost analysis gives different results. Of course, that's all just a wild guess.

[smeenai]

Ping.

[rjmccall]

In general, it's unfortunate that this has to leave so many C++-runtime-specific tendrils in the ObjC code. Unlike the EH type patch, though, I'm not sure I can see a great alternative here, especially because of the semantic restrictions required by outlining.

lib/CodeGen/CGCXXABI.h

248

Should you just generalize the existing method to only take a VarDecl* so it can be used for either kind of catch?

[rnk]

In D47988#1135533, @rjmccall wrote:

In general, it's unfortunate that this has to leave so many C++-runtime-specific tendrils in the ObjC code. Unlike the EH type patch, though, I'm not sure I can see a great alternative here, especially because of the semantic restrictions required by outlining.

It's technically possible to lift those restrictions by returning an i32 from the outlined function and switching on it. Right? The question is, is it worth it? The catch funclet would effectively store the i32 to the stack frame, then "catchret" via the runtime, and then we'd switch out to the jump target.

[rjmccall]

In D47988#1135929, @rnk wrote:

In D47988#1135533, @rjmccall wrote:

In general, it's unfortunate that this has to leave so many C++-runtime-specific tendrils in the ObjC code. Unlike the EH type patch, though, I'm not sure I can see a great alternative here, especially because of the semantic restrictions required by outlining.

It's technically possible to lift those restrictions by returning an i32 from the outlined function and switching on it. Right? The question is, is it worth it? The catch funclet would effectively store the i32 to the stack frame, then "catchret" via the runtime, and then we'd switch out to the jump target.

I don't think it's important. Uses of control flow out of @finally are rare, and we could probably forbid it entirely without significant loss.

[smeenai]

lib/CodeGen/CGCXXABI.h

248

The Itanium version of emitBeginCatch actually uses the statement for location info (it calls getLocStart on it). I suppose I could generalize the existing method to take both a VarDecl* and a SourceLocation though.

lib/CodeGen/CGCXXABI.h

public:
   virtual llvm::GlobalVariable *getThrowInfo(QualType T) { return nullptr; }
 
   /// Determine whether it's possible to emit a vtable for \p RD, even
   /// though we do not know that the vtable has been marked as used by semantic
   /// analysis.
   virtual bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const = 0;
 
   virtual void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) = 0;
+  virtual void emitBeginCatch(CodeGenFunction &CGF, const VarDecl *CatchParam) {
+    llvm_unreachable("Only needed for the Microsoft ABI");
+  }
 
   virtual llvm::CallInst *
   emitTerminateForUnexpectedException(CodeGenFunction &CGF,
                                       llvm::Value *Exn);
 
   virtual llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) = 0;
   virtual llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty,
                                                   StringRef MangledName) {

lib/CodeGen/CGException.cpp

namespace {
   };
 
   struct PerformFinally final : EHScopeStack::Cleanup {
     const Stmt *Body;
     llvm::Value *ForEHVar;
     llvm::Value *EndCatchFn;
     llvm::Value *RethrowFn;
     llvm::Value *SavedExnVar;
+    bool IsOutlined;
 
     PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
-                   llvm::Value *EndCatchFn,
-                   llvm::Value *RethrowFn, llvm::Value *SavedExnVar)
+                   llvm::Value *EndCatchFn, llvm::Value *RethrowFn,
+                   llvm::Value *SavedExnVar, bool IsOutlined)
         : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
-        RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
+          RethrowFn(RethrowFn), SavedExnVar(SavedExnVar),
+          IsOutlined(IsOutlined) {}
 
     void Emit(CodeGenFunction &CGF, Flags flags) override {
+      if (IsOutlined) {
+        // Just emit the call to the outlined finally.
+        CGF.EmitStmt(Body);
+        return;
+      }
+
       // Enter a cleanup to call the end-catch function if one was provided.
       if (EndCatchFn)
         CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup,
                                                         ForEHVar, EndCatchFn);
 
       // Save the current cleanup destination in case there are
       // cleanups in the finally block.
       llvm::Value *SavedCleanupDest =
void Emit(CodeGenFunction &CGF, Flags flags) override {
       // Leave the end-catch cleanup.  As an optimization, pretend that
       // the fallthrough path was inaccessible; we've dynamically proven
       // that we're not in the EH case along that path.
       if (EndCatchFn) {
         CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
         CGF.PopCleanupBlock();
         CGF.Builder.restoreIP(SavedIP);
       }
-    
       // Now make sure we actually have an insertion point or the
       // cleanup gods will hate us.
       CGF.EnsureInsertPoint();
     }
   };
 } // end anonymous namespace
 
 /// Enters a finally block for an implementation using zero-cost
 /// exceptions.  This is mostly general, but hard-codes some
 /// language/ABI-specific behavior in the catch-all sections.
 void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF,
                                          const Stmt *body,
                                          llvm::Constant *beginCatchFn,
                                          llvm::Constant *endCatchFn,
                                          llvm::Constant *rethrowFn) {
   assert((beginCatchFn != nullptr) == (endCatchFn != nullptr) &&
          "begin/end catch functions not paired");
   assert(rethrowFn && "rethrow function is required");
 
+  // A finally block is a statement which must be executed on any edge
+  // out of a given scope.  Unlike a cleanup, the finally block may
+  // contain arbitrary control flow leading out of itself.  In
+  // addition, finally blocks should always be executed, even if there
+  // are no catch handlers higher on the stack.  Therefore, we
+  // surround the protected scope with a combination of a normal
+  // cleanup (to catch attempts to break out of the block via normal
+  // control flow) and an EH catch-all (semantically "outside" any try
+  // statement to which the finally block might have been attached).
+  // The finally block itself is generated in the context of a cleanup
+  // which conditionally leaves the catch-all.
+
+  // For funclet-based EH (such as Windows MSVC), we cannot branch out of the
+  // catch-all to the cleanup, since the only valid way to leave the catch-all
+  // scope would be via a catchret, which would destroy the exception. Instead,
+  // we expect the frontend to outline the body of the finally, so that it can
+  // be called separately from both the catch-all and the cleanup. This also
+  // means we do not currently support control flow leaving the finally (e.g.
+  // returns and gotos); the frontend will emit errors for that.
+  IsOutlined = CGF.CGM.getTriple().isWindowsMSVCEnvironment();
+  if (IsOutlined) {
+    assert(!beginCatchFn &&
+           "Should not have begin-catch function when @finally is outlined");
+    assert(!endCatchFn &&
+           "Should not have end-catch function when @finally is outlined");
+    FinallyBody = dyn_cast<CapturedStmt>(body);
+    assert(FinallyBody && "Outlined @finally should be a CapturedStmt");
+  } else {
     BeginCatchFn = beginCatchFn;
 
     // The rethrow function has one of the following two types:
     //   void (*)()
     //   void (*)(void*)
     // In the latter case we need to pass it the exception object.
     // But we can't use the exception slot because the @finally might
     // have a landing pad (which would overwrite the exception slot).
     llvm::FunctionType *rethrowFnTy =
       cast<llvm::FunctionType>(
         cast<llvm::PointerType>(rethrowFn->getType())->getElementType());
     SavedExnVar = nullptr;
     if (rethrowFnTy->getNumParams())
       SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn");
 
-  // A finally block is a statement which must be executed on any edge
-  // out of a given scope.  Unlike a cleanup, the finally block may
-  // contain arbitrary control flow leading out of itself.  In
-  // addition, finally blocks should always be executed, even if there
-  // are no catch handlers higher on the stack.  Therefore, we
-  // surround the protected scope with a combination of a normal
-  // cleanup (to catch attempts to break out of the block via normal
-  // control flow) and an EH catch-all (semantically "outside" any try
-  // statement to which the finally block might have been attached).
-  // The finally block itself is generated in the context of a cleanup
-  // which conditionally leaves the catch-all.
-
     // Jump destination for performing the finally block on an exception
     // edge.  We'll never actually reach this block, so unreachable is
     // fine.
     RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock());
 
     // Whether the finally block is being executed for EH purposes.
     ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh");
     CGF.Builder.CreateFlagStore(false, ForEHVar);
+  }
 
   // Enter a normal cleanup which will perform the @finally block.
-  CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body,
-                                          ForEHVar, endCatchFn,
-                                          rethrowFn, SavedExnVar);
+  CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body, ForEHVar,
+                                          endCatchFn, rethrowFn, SavedExnVar,
+                                          IsOutlined);
 
   // Enter a catch-all scope.
   llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall");
   EHCatchScope *catchScope = CGF.EHStack.pushCatch(1);
-  catchScope->setCatchAllHandler(0, catchBB);
+  catchScope->setHandler(0, CGF.CGM.getCXXABI().getCatchAllTypeInfo(), catchBB);
 }
 
 void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) {
   // Leave the finally catch-all.
   EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin());
   llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block;
 
   CGF.popCatchScope();
 
   // If there are any references to the catch-all block, emit it.
   if (catchBB->use_empty()) {
     delete catchBB;
   } else {
     CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
     CGF.EmitBlock(catchBB);
 
+    if (IsOutlined) {
+      SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
+          CGF.CurrentFuncletPad);
+      CGF.CurrentFuncletPad = catchBB->getFirstNonPHI();
+      CGF.EmitStmt(FinallyBody);
+      CGF.CGM.getCXXABI().emitRethrow(CGF, /*IsNoReturn=*/true);
+    } else {
       llvm::Value *exn = nullptr;
 
       // If there's a begin-catch function, call it.
       if (BeginCatchFn) {
         exn = CGF.getExceptionFromSlot();
         CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn);
       }
 
       // If we need to remember the exception pointer to rethrow later, do so.
       if (SavedExnVar) {
         if (!exn) exn = CGF.getExceptionFromSlot();
         CGF.Builder.CreateAlignedStore(exn, SavedExnVar, CGF.getPointerAlign());
       }
 
       // Tell the cleanups in the finally block that we're do this for EH.
       CGF.Builder.CreateFlagStore(true, ForEHVar);
 
       // Thread a jump through the finally cleanup.
       CGF.EmitBranchThroughCleanup(RethrowDest);
+    }
 
     CGF.Builder.restoreIP(savedIP);
   }
 
   // Finally, leave the @finally cleanup.
   CGF.PopCleanupBlock();
 }
 

lib/CodeGen/CGObjCGNU.cpp

CGObjCGNUstep(CodeGenModule &Mod, unsigned ABI, unsigned ProtocolABI,
       SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
                         SelectorTy, IdTy);
       // Slot_t objc_slot_lookup_super(struct objc_super*, SEL);
       SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
                              PtrToObjCSuperTy, SelectorTy);
       // If we're in ObjC++ mode, then we want to make 
       if (CGM.getLangOpts().CPlusPlus) {
         llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
+        if (!CGM.getTriple().isWindowsMSVCEnvironment()) {
           // void *__cxa_begin_catch(void *e)
           EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy);
           // void __cxa_end_catch(void)
           ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy);
+        }
         // void _Unwind_Resume_or_Rethrow(void*)
         ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy,
                                 PtrTy);
       } else if (R.getVersion() >= VersionTuple(1, 7)) {
         llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
+        if (!CGM.getTriple().isWindowsMSVCEnvironment()) {
           // id objc_begin_catch(void *e)
           EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy);
           // void objc_end_catch(void)
           ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy);
+        }
         // void _Unwind_Resume_or_Rethrow(void*)
         ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy, PtrTy);
       }
       llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
       SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy,
                              SelectorTy, IdTy, PtrDiffTy);
       SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy,
                                  IdTy, SelectorTy, IdTy, PtrDiffTy);

lib/CodeGen/CGObjCMac.cpp

llvm::Constant *getMessageSendSuper2StretFixupFn() {
     //                                   struct _super_message_ref_t*, ...)
     llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
     return  CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
                                                               params, true),
                                       "objc_msgSendSuper2_stret_fixup");
   }
 
   llvm::Constant *getObjCEndCatchFn() {
+    if (CGM.getTriple().isWindowsMSVCEnvironment())
+      return nullptr;
+
     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
                                      "objc_end_catch");
 
   }
 
   llvm::Constant *getObjCBeginCatchFn() {
+    if (CGM.getTriple().isWindowsMSVCEnvironment())
+      return nullptr;
+
     llvm::Type *params[] = { Int8PtrTy };
     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
                                                              params, false),
                                      "objc_begin_catch");
   }
 
   llvm::StructType *EHTypeTy;
   llvm::Type *EHTypePtrTy;
CGObjCNonFragileABIMac::GetEHType(QualType T) {
   }
 
   return GetInterfaceEHType(ID, NotForDefinition);
 }
 
 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
                                          const ObjCAtTryStmt &S) {
   EmitTryCatchStmt(CGF, S,
-      cast<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
-      cast<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
+      cast_or_null<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
+      cast_or_null<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
       cast<llvm::Function>(ObjCTypes.getExceptionRethrowFn()));
 }
 
 /// EmitThrowStmt - Generate code for a throw statement.
 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
                                            const ObjCAtThrowStmt &S,
                                            bool ClearInsertionPoint) {
   if (const Expr *ThrowExpr = S.getThrowExpr()) {

lib/CodeGen/CGObjCRuntime.cpp

 //==- CGObjCRuntime.cpp - Interface to Shared Objective-C Runtime Features ==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This abstract class defines the interface for Objective-C runtime-specific
 // code generation.  It provides some concrete helper methods for functionality
 // shared between all (or most) of the Objective-C runtimes supported by clang.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CGObjCRuntime.h"
+#include "CGCXXABI.h"
 #include "CGCleanup.h"
 #include "CGRecordLayout.h"
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "llvm/IR/CallSite.h"
+#include "llvm/Support/SaveAndRestore.h"
 
 using namespace clang;
 using namespace CodeGen;
 
 uint64_t CGObjCRuntime::ComputeIvarBaseOffset(CodeGen::CodeGenModule &CGM,
                                               const ObjCInterfaceDecl *OID,
                                               const ObjCIvarDecl *Ivar) {
   return CGM.getContext().lookupFieldBitOffset(OID, nullptr, Ivar) /
return LValue::MakeBitfield(Addr, *Info, IvarTy,
                               TBAAAccessInfo());
 }
 
 namespace {
   struct CatchHandler {
     const VarDecl *Variable;
     const Stmt *Body;
     llvm::BasicBlock *Block;
-    llvm::Constant *TypeInfo;
+    CatchTypeInfo TypeInfo;
   };
 
   struct CallObjCEndCatch final : EHScopeStack::Cleanup {
     CallObjCEndCatch(bool MightThrow, llvm::Value *Fn)
         : MightThrow(MightThrow), Fn(Fn) {}
     bool MightThrow;
     llvm::Value *Fn;
 
for (unsigned I = 0, N = S.getNumCatchStmts(); I != N; ++I) {
       Handlers.push_back(CatchHandler());
       CatchHandler &Handler = Handlers.back();
       Handler.Variable = CatchDecl;
       Handler.Body = CatchStmt->getCatchBody();
       Handler.Block = CGF.createBasicBlock("catch");
 
       // @catch(...) always matches.
       if (!CatchDecl) {
-        Handler.TypeInfo = nullptr; // catch-all
+        Handler.TypeInfo = CGF.CGM.getCXXABI().getCatchAllTypeInfo();
         // Don't consider any other catches.
         break;
       }
 
-      Handler.TypeInfo = GetEHType(CatchDecl->getType());
+      Handler.TypeInfo = {GetEHType(CatchDecl->getType()), 0};
     }
 
     EHCatchScope *Catch = CGF.EHStack.pushCatch(Handlers.size());
     for (unsigned I = 0, E = Handlers.size(); I != E; ++I)
       Catch->setHandler(I, Handlers[I].TypeInfo, Handlers[I].Block);
   }
   
   // Emit the try body.
   CGF.EmitStmt(S.getTryBody());
 
   // Leave the try.
   if (S.getNumCatchStmts())
     CGF.popCatchScope();
 
   // Remember where we were.
   CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
 
   // Emit the handlers.
   for (unsigned I = 0, E = Handlers.size(); I != E; ++I) {
     CatchHandler &Handler = Handlers[I];
+    if (Handler.Block->use_empty()) {
+      delete Handler.Block;
+      continue;
+    }
 
     CGF.EmitBlock(Handler.Block);
+
+    CodeGenFunction::LexicalScope cleanups(CGF, Handler.Body->getSourceRange());
+
+    bool RuntimeCopiesExn = CGF.CGM.getTriple().isWindowsMSVCEnvironment();
+    assert(!(RuntimeCopiesExn && beginCatchFn) &&
+           "Should not have begin-catch function if runtime copies exception");
+    assert(!(RuntimeCopiesExn && endCatchFn) &&
+           "Should not have end-catch function if runtime copies exception");
+
+    if (RuntimeCopiesExn) {
+      SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
+          CGF.CurrentFuncletPad);
+      CGF.CGM.getCXXABI().emitBeginCatch(CGF, Handler.Variable);
+      if (Handler.Variable && Handler.Variable->getDeclName())
+        EmitInitOfCatchParam(CGF, nullptr, Handler.Variable);
+
+      CGF.EmitStmt(Handler.Body);
+
+      // Leave any cleanups associated with the catch before we exit the
+      // catchpad funclet scope.
+      cleanups.ForceCleanup();
+    } else {
       llvm::Value *RawExn = CGF.getExceptionFromSlot();
 
       // Enter the catch.
       llvm::Value *Exn = RawExn;
       if (beginCatchFn)
         Exn = CGF.EmitNounwindRuntimeCall(beginCatchFn, RawExn, "exn.adjusted");
 
-    CodeGenFunction::LexicalScope cleanups(CGF, Handler.Body->getSourceRange());
-
       if (endCatchFn) {
         // Add a cleanup to leave the catch.
         bool EndCatchMightThrow = (Handler.Variable == nullptr);
 
         CGF.EHStack.pushCleanup<CallObjCEndCatch>(NormalAndEHCleanup,
                                                   EndCatchMightThrow,
                                                   endCatchFn);
       }
 
       // Bind the catch parameter if it exists.
       if (const VarDecl *CatchParam = Handler.Variable) {
         llvm::Type *CatchType = CGF.ConvertType(CatchParam->getType());
         llvm::Value *CastExn = CGF.Builder.CreateBitCast(Exn, CatchType);
 
         CGF.EmitAutoVarDecl(*CatchParam);
         EmitInitOfCatchParam(CGF, CastExn, CatchParam);
       }
 
       CGF.ObjCEHValueStack.push_back(Exn);
       CGF.EmitStmt(Handler.Body);
       CGF.ObjCEHValueStack.pop_back();
 
       // Leave any cleanups associated with the catch.
       cleanups.ForceCleanup();
+    }
 
     CGF.EmitBranchThroughCleanup(Cont);
-  }  
+  }
 
   // Go back to the try-statement fallthrough.
   CGF.Builder.restoreIP(SavedIP);
 
   // Pop out of the finally.
   if (S.getFinallyStmt())
     FinallyInfo.exit(CGF);
 
   if (Cont.isValid())
     CGF.EmitBlock(Cont.getBlock());
 }
 
 void CGObjCRuntime::EmitInitOfCatchParam(CodeGenFunction &CGF,
                                          llvm::Value *exn,
                                          const VarDecl *paramDecl) {
-
   Address paramAddr = CGF.GetAddrOfLocalVar(paramDecl);
+  // If exn is nullptr, the exception object has been copied into paramAddr by
+  // the runtime, and we can load it from there (and don't need to store it
+  // back). We perform the loads lazily to avoid emitting the load instruction
+  // unless it's needed.
+  bool RuntimeCopiesExn = (exn == nullptr);
 
   switch (paramDecl->getType().getQualifiers().getObjCLifetime()) {
   case Qualifiers::OCL_Strong:
+    if (RuntimeCopiesExn)
+      exn = CGF.Builder.CreateLoad(paramAddr);
     exn = CGF.EmitARCRetainNonBlock(exn);
     // fallthrough
 
   case Qualifiers::OCL_None:
   case Qualifiers::OCL_ExplicitNone:
   case Qualifiers::OCL_Autoreleasing:
+    if (!RuntimeCopiesExn)
       CGF.Builder.CreateStore(exn, paramAddr);
     return;
 
   case Qualifiers::OCL_Weak:
+    if (RuntimeCopiesExn)
+      exn = CGF.Builder.CreateLoad(paramAddr);
     CGF.EmitARCInitWeak(paramAddr, exn);
     return;
   }
   llvm_unreachable("invalid ownership qualifier");
 }
 
 namespace {
   struct CallSyncExit final : EHScopeStack::Cleanup {

lib/CodeGen/CGStmt.cpp

 /// captured variables into the captured struct, and call the outlined function.
 llvm::Function *
 CodeGenFunction::EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K) {
   LValue CapStruct = InitCapturedStruct(S);
 
   // Emit the CapturedDecl
   CodeGenFunction CGF(CGM, true);
   CGCapturedStmtRAII CapInfoRAII(CGF, new CGCapturedStmtInfo(S, K));
-  llvm::Function *F = CGF.GenerateCapturedStmtFunction(S);
+  llvm::Function *&F = CapturedStmtGeneratedFunctionMap[&S];
+  if (!F)
+    F = CGF.GenerateCapturedStmtFunction(S);
   delete CGF.CapturedStmtInfo;
 
   // Emit call to the helper function.
   EmitCallOrInvoke(F, CapStruct.getPointer());
 
   return F;
 }
 

lib/CodeGen/CodeGenFunction.h

public:
     CGCapturedStmtRAII(CodeGenFunction &CGF,
                        CGCapturedStmtInfo *NewCapturedStmtInfo)
         : CGF(CGF), PrevCapturedStmtInfo(CGF.CapturedStmtInfo) {
       CGF.CapturedStmtInfo = NewCapturedStmtInfo;
     }
     ~CGCapturedStmtRAII() { CGF.CapturedStmtInfo = PrevCapturedStmtInfo; }
   };
 
+  /// Map a CapturedStmt to its generated function.
+  llvm::DenseMap<const CapturedStmt *, llvm::Function *>
+      CapturedStmtGeneratedFunctionMap;
+
   /// An abstract representation of regular/ObjC call/message targets.
   class AbstractCallee {
     /// The function declaration of the callee.
     const Decl *CalleeDecl;
 
   public:
     AbstractCallee() : CalleeDecl(nullptr) {}
     AbstractCallee(const FunctionDecl *FD) : CalleeDecl(FD) {}
class FinallyInfo {
     /// An i1 variable indicating whether or not the @finally is
     /// running for an exception.
     llvm::AllocaInst *ForEHVar;
 
     /// An i8* variable into which the exception pointer to rethrow
     /// has been saved.
     llvm::AllocaInst *SavedExnVar;
 
+    /// Whether the finally is expected to have been outlined by the frontend.
+    bool IsOutlined;
+
+    /// The outlined finally body.
+    const CapturedStmt *FinallyBody;
+
   public:
     void enter(CodeGenFunction &CGF, const Stmt *Finally,
                llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn,
                llvm::Constant *rethrowFn);
     void exit(CodeGenFunction &CGF);
   };
 
   /// Returns true inside SEH __try blocks.

lib/CodeGen/MicrosoftCXXABI.cpp

public:
   void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE,
                                Address Ptr, QualType ElementType,
                                const CXXDestructorDecl *Dtor) override;
 
   void emitRethrow(CodeGenFunction &CGF, bool isNoReturn) override;
   void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) override;
 
   void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C) override;
+  void emitBeginCatch(CodeGenFunction &CGF, const VarDecl *CatchParam) override;
 
   llvm::GlobalVariable *getMSCompleteObjectLocator(const CXXRecordDecl *RD,
                                                    const VPtrInfo &Info);
 
   llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty) override;
   llvm::Constant *getAddrOfRTTIDescriptor(QualType Ty,
                                           StringRef MangledName) override;
   CatchTypeInfo
void MicrosoftCXXABI::emitRethrow(CodeGenFunction &CGF, bool isNoReturn) {
   if (isNoReturn)
     CGF.EmitNoreturnRuntimeCallOrInvoke(Fn, Args);
   else
     CGF.EmitRuntimeCallOrInvoke(Fn, Args);
 }
 
 void MicrosoftCXXABI::emitBeginCatch(CodeGenFunction &CGF,
                                      const CXXCatchStmt *S) {
+  emitBeginCatch(CGF, S->getExceptionDecl());
+}
+
+void MicrosoftCXXABI::emitBeginCatch(CodeGenFunction &CGF,
+                                     const VarDecl *CatchParam) {
   // In the MS ABI, the runtime handles the copy, and the catch handler is
   // responsible for destruction.
-  VarDecl *CatchParam = S->getExceptionDecl();
   llvm::BasicBlock *CatchPadBB = CGF.Builder.GetInsertBlock();
   llvm::CatchPadInst *CPI =
       cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI());
   CGF.CurrentFuncletPad = CPI;
 
   // If this is a catch-all or the catch parameter is unnamed, we don't need to
   // emit an alloca to the object.
   if (!CatchParam || !CatchParam->getDeclName()) {

test/CodeGenObjC/catch-lexical-block.m

-// RUN: %clang_cc1 -debug-info-kind=limited -fobjc-exceptions -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -debug-info-kind=limited -fexceptions -fobjc-exceptions -emit-llvm %s -o - | FileCheck %s
 @interface Foo @end
 void f0() {
   @try {
     @throw @"a";
   } @catch(Foo *e) {
   }
 }
 
 // We should have 3 lexical blocks here at the moment, including one
 // for the catch block.
 // CHECK: !DILexicalBlock(
 // CHECK: !DILocalVariable(
 // CHECK: !DILexicalBlock(
 // CHECK: !DILexicalBlock(

test/CodeGenObjC/exceptions-msvc.m

-// RUN: %clang_cc1 -triple i686--windows-msvc -fobjc-runtime=ios-6.0 -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X86 %s
-// RUN: %clang_cc1 -triple i686--windows-msvc -fobjc-runtime=ios-6.0 -fobjc-arc -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X86 %s
-// RUN: %clang_cc1 -triple x86_64--windows-msvc -fobjc-runtime=ios-6.0 -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X64 %s
-// RUN: %clang_cc1 -triple x86_64--windows-msvc -fobjc-runtime=ios-6.0 -fobjc-arc -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X64 %s
+// RUN: %clang_cc1 -triple i686--windows-msvc -fobjc-runtime=ios-6.0 -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X86 --enable-var-scope %s
+// RUN: %clang_cc1 -triple i686--windows-msvc -fobjc-runtime=ios-6.0 -fobjc-arc -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X86,ARC --enable-var-scope %s
+// RUN: %clang_cc1 -triple x86_64--windows-msvc -fobjc-runtime=ios-6.0 -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X64 --enable-var-scope %s
+// RUN: %clang_cc1 -triple x86_64--windows-msvc -fobjc-runtime=ios-6.0 -fobjc-arc -fdeclspec -fexceptions -fobjc-exceptions -emit-llvm -o - %s | FileCheck -check-prefixes=CHECK,X64,ARC --enable-var-scope %s
 
 #if __has_feature(objc_arc)
 #define WEAK __weak
 #else
 #define WEAK
 #endif
 
 // CHECK-DAG: $OBJC_EHTYPE_id = comdat any

 @implementation N
 @end
 
 // CHECK-NOT: @"OBJC_EHTYPE_$_N"
 
 @protocol P;
 
 void f(void);
+void __declspec(nothrow) g(void);
 
-void g() {
+void generate_ehtypes() {
   @try {
     f();
   } @catch (I *) {
   } @catch (J<P> *) {
   } @catch (K *) {
   } @catch (L *) {
   } @catch (M *WEAK) {
   } @catch (id) {
   }
 }
+
+void basic_try_catch_1() {
+  @try {
+    f();
+  } @catch (...) {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @basic_try_catch_1(){{.*}} {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    invoke void @f()
+// CHECK-NEXT:            to label %[[INVOKECONT:[^ ]+]] unwind label %[[DISPATCH:[^ ]+]]
+// CHECK:       [[DISPATCH]]:
+// CHECK-NEXT:    %[[CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[CATCH:[^ ]+]]] unwind to caller
+// CHECK:       [[INVOKECONT]]:
+// CHECK-NEXT:    br label %[[EHCONT:[^ ]+]]
+// CHECK:       [[EHCONT]]:
+// CHECK-NEXT:    ret void
+// CHECK:       [[CATCH]]:
+// CHECK-NEXT:    %[[CATCHPAD:[^ ]+]] = catchpad within %[[CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
+// CHECK-NEXT:    catchret from %[[CATCHPAD]] to label %[[CATCHRETDEST:[^ ]+]]
+// CHECK:       [[CATCHRETDEST]]:
+// CHECK-NEXT:    br label %[[EHCONT]]
+// CHECK-NEXT:  }
+
+void basic_try_catch_2() {
+  @try {
+    f();
+  } @catch (id) {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @basic_try_catch_2(){{.*}} {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    invoke void @f()
+// CHECK-NEXT:            to label %[[INVOKECONT:[^ ]+]] unwind label %[[DISPATCH:[^ ]+]]
+// CHECK:       [[DISPATCH]]:
+// CHECK-NEXT:    %[[CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[CATCH:[^ ]+]]] unwind to caller
+// CHECK:       [[INVOKECONT]]:
+// CHECK-NEXT:    br label %[[EHCONT:[^ ]+]]
+// CHECK:       [[EHCONT]]:
+// CHECK-NEXT:    ret void
+// CHECK:       [[CATCH]]:
+// CHECK-NEXT:    %[[CATCHPAD:[^ ]+]] = catchpad within %[[CATCHSWITCH]] [i8* {{.*}}@OBJC_EHTYPE_id{{.*}}, i32 0, i8* null]
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
+// CHECK-NEXT:    catchret from %[[CATCHPAD]] to label %[[CATCHRETDEST:[^ ]+]]
+// CHECK:       [[CATCHRETDEST]]:
+// CHECK-NEXT:    br label %[[EHCONT]]
+// CHECK-NEXT:  }
+
+void basic_try_catch_3() {
+  @try {
+    f();
+  } @catch (I *e) {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @basic_try_catch_3(){{.*}} {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    %e = alloca %[[ETYPE:[^ ]+]]*
+// CHECK-NEXT:    invoke void @f()
+// CHECK-NEXT:            to label %[[INVOKECONT:[^ ]+]] unwind label %[[DISPATCH:[^ ]+]]
+// CHECK:       [[DISPATCH]]:
+// CHECK-NEXT:    %[[CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[CATCH:[^ ]+]]] unwind to caller
+// CHECK:       [[INVOKECONT]]:
+// CHECK-NEXT:    br label %[[EHCONT:[^ ]+]]
+// CHECK:       [[EHCONT]]:
+// CHECK-NEXT:    ret void
+// CHECK:       [[CATCH]]:
+// CHECK-NEXT:    %[[CATCHPAD:[^ ]+]] = catchpad within %[[CATCHSWITCH]] [i8* {{.*}}@"OBJC_EHTYPE_$_I"{{.*}}, i32 0, %[[ETYPE]]** %e]
+// ARC-NEXT:      %[[ELOAD:[^ ]+]] = load %[[ETYPE]]*, %[[ETYPE]]** %e
+// ARC-NEXT:      %[[CAST1:[^ ]+]] = bitcast %[[ETYPE]]* %[[ELOAD]] to i8*
+// ARC-NEXT:      call i8* @objc_retain(i8* %[[CAST1]]){{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
+// ARC-NEXT:      bitcast
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
+// ARC-NEXT:      %[[CAST2:[^ ]+]] = bitcast %[[ETYPE]]** %e to i8**
+// ARC-NEXT:      call void @objc_storeStrong(i8** %[[CAST2]], i8* null){{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
+// CHECK-NEXT:    catchret from %[[CATCHPAD]] to label %[[CATCHRETDEST:[^ ]+]]
+// CHECK:       [[CATCHRETDEST]]:
+// CHECK-NEXT:    br label %[[EHCONT]]
+// CHECK-NEXT:  }
+
+void multiple_catch() {
+  @try {
+    f();
+  } @catch (id) {
+    g();
+  } @catch (...) {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @multiple_catch(){{.*}} {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    invoke void @f()
+// CHECK-NEXT:            to label %[[INVOKECONT:[^ ]+]] unwind label %[[DISPATCH:[^ ]+]]
+// CHECK:       [[DISPATCH]]:
+// CHECK-NEXT:    %[[CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[CATCH1:[^ ]+]], label %[[CATCH2:[^ ]+]]] unwind to caller
+// CHECK:       [[INVOKECONT]]:
+// CHECK-NEXT:    br label %[[EHCONT:[^ ]+]]
+// CHECK:       [[EHCONT]]:
+// CHECK-NEXT:    ret void
+// CHECK:       [[CATCH1]]:
+// CHECK-NEXT:    %[[CATCHPAD1:[^ ]+]] = catchpad within %[[CATCHSWITCH]] [i8* {{.*}}@OBJC_EHTYPE_id{{.*}}, i32 0, i8* null]
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[CATCHPAD1]]) ]
+// CHECK-NEXT:    catchret from %[[CATCHPAD1]] to label %[[CATCHRETDEST1:[^ ]+]]
+// CHECK:       [[CATCHRETDEST1]]:
+// CHECK-NEXT:    br label %[[EHCONT]]
+// CHECK:       [[CATCH2]]:
+// CHECK-NEXT:    %[[CATCHPAD2:[^ ]+]] = catchpad within %[[CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[CATCHPAD2]]) ]
+// CHECK-NEXT:    catchret from %[[CATCHPAD2]] to label %[[CATCHRETDEST2:[^ ]+]]
+// CHECK:       [[CATCHRETDEST2]]:
+// CHECK-NEXT:    br label %[[EHCONT]]
+// CHECK-NEXT:  }
+
+void basic_try_finally() {
+  @try {
+    f();
+  } @finally {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @basic_try_finally(){{.*}} {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    %[[CAPTURE1:[^ ]+]] = alloca
+// CHECK-NEXT:    %[[CAPTURE2:[^ ]+]] = alloca
+// CHECK-NEXT:    invoke void @f()
+// CHECK-NEXT:            to label %[[INVOKECONT:[^ ]+]] unwind label %[[DISPATCH:[^ ]+]]
+// CHECK:       [[DISPATCH]]:
+// CHECK-NEXT:    %[[CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[CATCHALL:[^ ]+]]] unwind to caller
+// CHECK:       [[INVOKECONT]]:
+// CHECK-NEXT:    call void @[[FINALLY_FUNCTION:[^ ]+]]({{.*}} %[[CAPTURE2]])
+// CHECK-NEXT:    ret void
+// CHECK:       [[CATCHALL]]:
+// CHECK-NEXT:    %[[CATCHPAD:[^ ]+]] = catchpad within %[[CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @[[FINALLY_FUNCTION]]({{.*}} %[[CAPTURE1]])
+// CHECK-NEXT:    call void @_CxxThrowException(i8* null, %eh.ThrowInfo* null){{.*}} [ "funclet"(token %[[CATCHPAD]]) ]
+// CHECK-NEXT:    unreachable
+// CHECK-NEXT:  }
+
+// (CHECK-LABEL can't be used with a variable capture)
+// CHECK:      define internal void @[[FINALLY_FUNCTION]]{{.*}} {
+// CHECK:        call void @g()
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void basic_try_catch_finally() {
+  @try {
+    f();
+  } @catch (id) {
+    f();
+  } @catch (...) {
+    g();
+  } @finally {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @basic_try_catch_finally(){{.*}} {
+// CHECK:         invoke void @f()
+// CHECK-NEXT:            to label %[[INVOKECONT1:[^ ]+]] unwind label %[[DISPATCH1:[^ ]+]]
+// CHECK:       [[DISPATCH1]]:
+// CHECK-NEXT:    %[[CATCHSWITCH1:[^ ]+]] = catchswitch within none [label %[[CATCH1:[^ ]+]], label %[[CATCH2:[^ ]+]]] unwind label %[[DISPATCH2:[^ ]+]]
+// CHECK:       [[INVOKECONT1]]:
+// CHECK:         br label %[[CLEANUP:[^ ]+]]
+// CHECK:       [[CLEANUP]]:
+// CHECK-NEXT:    call void @[[FINALLY_FUNCTION:[^ ]+]]
+// CHECK:       [[CATCH1]]:
+// CHECK-NEXT:    %[[CATCHPAD1:[^ ]+]] = catchpad within %[[CATCHSWITCH1]] [i8* {{.*}}@OBJC_EHTYPE_id{{.*}}, i32 0, i8* null]
+// CHECK-NEXT:    invoke void @f() [ "funclet"(token %[[CATCHPAD1]]) ]
+// CHECK-NEXT:            to label %[[INVOKECONT2:[^ ]+]] unwind label %[[DISPATCH2]]
+// CHECK:       [[DISPATCH2]]:
+// CHECK-NEXT:    %[[CATCHSWITCH2:[^ ]+]] = catchswitch within none [label %[[CATCHALL:[^ ]+]]] unwind to caller
+// CHECK:       [[INVOKECONT2]]:
+// CHECK-NEXT:    catchret from %[[CATCHPAD1]] to label %[[CATCHRETDEST1:[^ ]+]]
+// CHECK:       [[CATCHRETDEST1]]:
+// CHECK:         br label %[[CLEANUP]]
+// CHECK:       [[CATCH2]]:
+// CHECK-NEXT:    %[[CATCHPAD2:[^ ]+]] = catchpad within %[[CATCHSWITCH1]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[CATCHPAD2]]) ]
+// CHECK-NEXT:    catchret from %[[CATCHPAD2]] to label %[[CATCHRETDEST2:[^ ]+]]
+// CHECK:       [[CATCHRETDEST2]]:
+// CHECK:         br label %cleanup
+// CHECK:       [[CATCHALL]]:
+// CHECK-NEXT:    %[[CATCHPAD3:[^ ]+]] = catchpad within %[[CATCHSWITCH2]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @[[FINALLY_FUNCTION]]{{.*}} [ "funclet"(token %[[CATCHPAD3]]) ]
+// CHECK-NEXT:    call void @_CxxThrowException(i8* null, %eh.ThrowInfo* null){{.*}} [ "funclet"(token %[[CATCHPAD3]]) ]
+// CHECK-NEXT:    unreachable
+
+// CHECK:      define internal void @[[FINALLY_FUNCTION]]{{.*}} {
+// CHECK:        call void @g()
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void nested_try_catch_finally_1() {
+  f();
+  @try {
+    f();
+    @try {
+      f();
+    } @catch (...) {
+      f();
+    } @finally {
+      f();
+    }
+  } @catch (...) {
+    g();
+  } @finally {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @nested_try_catch_finally_1(){{.*}} {
+// CHECK:         call void @f()
+// CHECK-NEXT:    invoke void @f()
+// CHECK-NEXT:            to label %[[OUTER_TRY_INVOKE_CONT:[^ ]+]] unwind label %[[OUTER_CATCH_DISPATCH:[^ ]+]]
+// CHECK:       [[OUTER_TRY_INVOKE_CONT]]:
+// CHECK:         invoke void @f()
+// CHECK-NEXT:            to label %[[INNER_TRY_INVOKE_CONT:[^ ]+]] unwind label %[[INNER_CATCH_DISPATCH:[^ ]+]]
+// CHECK:       [[INNER_CATCH_DISPATCH]]:
+// CHECK-NEXT:    %[[INNER_CATCH_CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[INNER_CATCH:[^ ]+]]] unwind label %[[INNER_FINALLY_DISPATCH:[^ ]+]]
+// CHECK:       [[INNER_TRY_INVOKE_CONT]]:
+// CHECK:         br label %[[INNER_CLEANUP:[^ ]+]]
+// CHECK:       [[INNER_CLEANUP]]:
+// CHECK-NEXT:    invoke void @[[INNER_FINALLY_FUNCTION:[^ ]+]]
+// CHECK-NEXT:            to label %[[INNER_CLEANUP_INVOKE_CONT:[^ ]+]] unwind label %[[OUTER_CATCH_DISPATCH]]
+// CHECK:       [[OUTER_CATCH_DISPATCH]]:
+// CHECK-NEXT:    %[[OUTER_CATCH_CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[OUTER_CATCH:[^ ]+]]] unwind label %[[OUTER_FINALLY_DISPATCH:[^ ]+]]
+// CHECK:       [[OUTER_FINALLY_DISPATCH]]:
+// CHECK-NEXT:    %[[OUTER_FINALLY_CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[OUTER_FINALLY:[^ ]+]]] unwind to caller
+// CHECK:       [[INNER_CLEANUP_INVOKE_CONT]]:
+// (the cleanup generates a switch; ignore those labels)
+// CHECK:       {{^[^ ]+}}:
+// CHECK:       {{^[^ ]+}}:
+// CHECK:       [[OUTER_CLEANUP:[^ ]+]]:
+// CHECK-NEXT:    call void @[[OUTER_FINALLY_FUNCTION:[^ ]+]]
+// CHECK:       [[INNER_CATCH]]:
+// CHECK-NEXT:    %[[INNER_CATCH_CATCHPAD:[^ ]+]] = catchpad within %[[INNER_CATCH_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    invoke void @f() [ "funclet"(token %[[INNER_CATCH_CATCHPAD]]) ]
+// CHECK-NEXT:            to label %[[INNER_CATCH_INVOKE_CONT:[^ ]+]] unwind label %[[INNER_FINALLY_DISPATCH]]
+// CHECK:       [[INNER_FINALLY_DISPATCH]]:
+// CHECK-NEXT:    %[[INNER_FINALLY_CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[INNER_FINALLY:[^ ]+]]] unwind label %[[OUTER_CATCH_DISPATCH]]
+// CHECK:       [[INNER_CATCH_INVOKE_CONT]]:
+// CHECK-NEXT:    catchret from %[[INNER_CATCH_CATCHPAD]] to label %[[INNER_CATCH_CATCHRET_DEST:[^ ]+]]
+// CHECK:       [[INNER_CATCH_CATCHRET_DEST]]:
+// CHECK:         br label %[[INNER_CLEANUP]]
+// CHECK:       [[INNER_FINALLY]]:
+// CHECK-NEXT:    %[[INNER_FINALLY_CATCHPAD:[^ ]+]] = catchpad within %[[INNER_FINALLY_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    invoke void @[[INNER_FINALLY_FUNCTION:[^ ]+]]{{.*}} [ "funclet"(token %[[INNER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:            to label %[[INNER_FINALLY_INVOKE_CONT:[^ ]+]] unwind label %[[OUTER_CATCH_DISPATCH]]
+// CHECK:       [[INNER_FINALLY_INVOKE_CONT]]:
+// CHECK-NEXT:    invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null){{.*}} [ "funclet"(token %[[INNER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:            to label %unreachable unwind label %[[OUTER_CATCH_DISPATCH]]
+// CHECK:       [[OUTER_CATCH]]:
+// CHECK-NEXT:    %[[OUTER_CATCH_CATCHPAD:[^ ]+]] = catchpad within %[[OUTER_CATCH_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[OUTER_CATCH_CATCHPAD]]) ]
+// CHECK-NEXT:    catchret from %[[OUTER_CATCH_CATCHPAD]] to label %[[OUTER_CATCH_CATCHRET_DEST:[^ ]+]]
+// CHECK:       [[OUTER_CATCH_CATCHRET_DEST]]:
+// CHECK:         br label %[[OUTER_CLEANUP]]
+// CHECK:       [[OUTER_FINALLY]]:
+// CHECK-NEXT:    %[[OUTER_FINALLY_CATCHPAD:[^ ]+]] = catchpad within %[[OUTER_FINALLY_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @[[OUTER_FINALLY_FUNCTION]]{{.*}} [ "funclet"(token %[[OUTER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:    call void @_CxxThrowException(i8* null, %eh.ThrowInfo* null){{.*}} [ "funclet"(token %[[OUTER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:    unreachable
+
+// CHECK:      define internal void @[[INNER_FINALLY_FUNCTION]]{{.*}} {
+// CHECK:        call void @f()
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK:      define internal void @[[OUTER_FINALLY_FUNCTION]]{{.*}} {
+// CHECK:        call void @g()
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void nested_try_catch_finally_2() {
+  @try {
+    f();
+  } @catch (...) {
+    f();
+    @try {
+      f();
+    } @catch (...) {
+      g();
+    } @finally {
+      f();
+    }
+  } @finally {
+    g();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @nested_try_catch_finally_2(){{.*}} {
+// CHECK:         invoke void @f()
+// CHECK-NEXT:            to label %[[OUTER_TRY_INVOKE_CONT:[^ ]+]] unwind label %[[OUTER_CATCH_DISPATCH:[^ ]+]]
+// CHECK:       [[OUTER_CATCH_DISPATCH]]:
+// CHECK-NEXT:    %[[OUTER_CATCH_CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[OUTER_CATCH:[^ ]+]]] unwind label %[[OUTER_FINALLY_DISPATCH:[^ ]+]]
+// CHECK:       [[OUTER_TRY_INVOKE_CONT]]:
+// CHECK:         br label %[[OUTER_CLEANUP:[^ ]+]]
+// CHECK:       [[OUTER_CLEANUP]]:
+// CHECK-NEXT:    call void @[[OUTER_FINALLY_FUNCTION:[^ ]+]]
+// CHECK:       [[OUTER_CATCH]]:
+// CHECK-NEXT:    %[[OUTER_CATCH_CATCHPAD:[^ ]+]] = catchpad within %[[OUTER_CATCH_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    invoke void @f() [ "funclet"(token %[[OUTER_CATCH_CATCHPAD]]) ]
+// CHECK-NEXT:            to label %[[INNER_TRY:[^ ]+]] unwind label %[[OUTER_FINALLY_DISPATCH]]
+// CHECK:       [[INNER_TRY]]:
+// CHECK-NEXT:    invoke void @f() [ "funclet"(token %[[OUTER_CATCH_CATCHPAD]]) ]
+// CHECK-NEXT:            to label %[[INNER_TRY_INVOKE_CONT:[^ ]+]] unwind label %[[INNER_CATCH_DISPATCH:[^ ]+]]
+// CHECK:       [[INNER_CATCH_DISPATCH]]:
+// CHECK-NEXT:    %[[INNER_CATCH_CATCHSWITCH:[^ ]+]] = catchswitch within %[[OUTER_CATCH_CATCHPAD]] [label %[[INNER_CATCH:[^ ]+]]] unwind label %[[INNER_FINALLY_DISPATCH:[^ ]+]]
+// CHECK:       [[INNER_FINALLY_DISPATCH]]:
+// CHECK-NEXT:    %[[INNER_FINALLY_CATCHSWITCH:[^ ]+]] = catchswitch within %[[OUTER_CATCH_CATCHPAD]] [label %[[INNER_FINALLY:[^ ]+]]] unwind label %[[OUTER_FINALLY_DISPATCH]]
+// CHECK:       [[INNER_TRY_INVOKE_CONT]]:
+// CHECK:         br label %[[INNER_CLEANUP:[^ ]+]]
+// CHECK:       [[INNER_CLEANUP]]:
+// CHECK-NEXT:    invoke void @[[INNER_FINALLY_FUNCTION:[^ ]+]]
+// CHECK-NEXT:            to label %[[INNER_CLEANUP_INVOKE_CONT:[^ ]+]] unwind label %[[OUTER_FINALLY_DISPATCH]]
+// CHECK:       [[OUTER_FINALLY_DISPATCH]]:
+// CHECK-NEXT:    %[[OUTER_FINALLY_CATCHSWITCH:[^ ]+]] = catchswitch within none [label %[[OUTER_FINALLY:[^ ]+]]] unwind to caller
+// CHECK:       [[INNER_CLEANUP_INVOKE_CONT]]:
+// CHECK:         catchret from %[[OUTER_CATCH_CATCHPAD]] to label %[[OUTER_CATCH_CATCHRET_DEST:[^ ]+]]
+// CHECK:       [[OUTER_CATCH_CATCHRET_DEST]]:
+// CHECK:         br label %[[OUTER_CLEANUP]]
+// CHECK:       [[INNER_CATCH]]:
+// CHECK-NEXT:    %[[INNER_CATCH_CATCHPAD:[^ ]+]] = catchpad within %[[INNER_CATCH_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @g(){{.*}} [ "funclet"(token %[[INNER_CATCH_CATCHPAD]]) ]
+// CHECK-NEXT:    catchret from %[[INNER_CATCH_CATCHPAD]] to label %[[INNER_CATCH_CATCHRET_DEST:[^ ]+]]
+// CHECK:       [[INNER_CATCH_CATCHRET_DEST]]:
+// CHECK:         br label %[[INNER_CLEANUP]]
+// CHECK:       [[INNER_FINALLY]]:
+// CHECK-NEXT:    %[[INNER_FINALLY_CATCHPAD:[^ ]+]] = catchpad within %[[INNER_FINALLY_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    invoke void @[[INNER_FINALLY_FUNCTION]]{{.*}} [ "funclet"(token %[[INNER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:            to label %[[INNER_FINALLY_INVOKE_CONT:[^ ]+]] unwind label %[[OUTER_FINALLY_DISPATCH]]
+// CHECK:       [[INNER_FINALLY_INVOKE_CONT]]:
+// CHECK-NEXT:    invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null){{.*}} [ "funclet"(token %[[INNER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:            to label %unreachable unwind label %[[OUTER_FINALLY_DISPATCH]]
+// CHECK:       [[OUTER_FINALLY]]:
+// CHECK-NEXT:    %[[OUTER_FINALLY_CATCHPAD:[^ ]+]] = catchpad within %[[OUTER_FINALLY_CATCHSWITCH]] [i8* null, i32 64, i8* null]
+// CHECK-NEXT:    call void @[[OUTER_FINALLY_FUNCTION]]{{.*}} [ "funclet"(token %[[OUTER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:    call void @_CxxThrowException(i8* null, %eh.ThrowInfo* null){{.*}} [ "funclet"(token %[[OUTER_FINALLY_CATCHPAD]]) ]
+// CHECK-NEXT:    unreachable
+
+// CHECK:      define internal void @[[INNER_FINALLY_FUNCTION]]{{.*}} {
+// CHECK:        call void @f()
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+// CHECK:      define internal void @[[OUTER_FINALLY_FUNCTION]]{{.*}} {
+// CHECK:        call void @g()
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void empty_try_catch() {
+  @try {
+  } @catch (...) {
+    f();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @empty_try_catch(){{.*}} {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    br label %[[EHCONT:[^ ]+]]
+// CHECK:       [[EHCONT]]:
+// CHECK-NEXT:    ret void
+// CHECK-NEXT:  }
+
+void empty_try_finally() {
+  @try {
+  } @finally {
+    f();
+  }
+}
+
+// CHECK-LABEL: define {{.*}}void @empty_try_finally(){{.*}} {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    %[[CAPTURED:[^ ]+]] = alloca
+// CHECK-NEXT:    call void @[[FINALLY_FUNCTION:[^ ]+]]({{.*}} %[[CAPTURED]])
+// CHECK-NEXT:    ret void
+// CHECK-NEXT:  }
+
+// CHECK:      define internal void @[[FINALLY_FUNCTION]]{{.*}} {
+// CHECK:        call void @f()
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }