Extended support for native Windows C++ EH outlining

[andrew.w.kaylor]

Summary

This patch adds landing block pre-analysis support, catch and cleanup handler pruning, shared and nested handler support and landing pad body replacement (with a preliminary form of the yet to be finalized llvm.eh.actions intrinsic).

I'd be happy to peel off parts of this for smaller change sets, but I think this is more or less ready for a proper review.

[majnemer]

lib/CodeGen/WinEHPrepare.cpp

92

I'd typedef SmallSet<BasicBlock *, 4> in case we'd like to change it later.

1118–1119

Please fold these lines together.

1136

Please reformat this.

1166–1169

Would this be simpler if you initialized your iterator to the instruction at BB->getFirstNonPHIOrDbg()?

1226–1227

Same line please.

[majnemer]

lib/CodeGen/WinEHPrepare.cpp

411–413

This can just be DeleteContainerPointers(Actions).

424

This can be a const method.

426–427

Can you use SmallVectorImpl instead of SmallVector<ActionHandler *, 4> here?

530–531

Please stick the else on the same line as the }

549–551

Please consistently use braces here.

552–553

This can be simplified to just auto *ParentInst = cast<Instruction>(ParentVal);

564–565

Same line please.

578

Is it ever OK for AllocaInsertPt to be null? If not, use cast instead of dyn_cast.

667–676

I'm guessing we are not going to want to always give them ExternalLinkage but I guess we can fix that later. Perhaps we should have a TODO?

762–764

Might be a little easier to read as:

if (!Store)
  continue;

924–925

This can simply be:

if (isa<LandingPadInst>(&Inst))
  continue;

948–949

Please fold these two lines together.

966–968

This can simply be:

if (match(&Inst, m_Intrinsic<Intrinsic::eh_endcatch>()))
  continue;

970–971

Please fold these two lines together.

991–992

Please fold these lines together.

1008–1009

Please fold these lines together.

1135–1136

Please fold these lines together.

1155–1156

Please fold these lines together.

1165–1166

You can use cast instead of dyn_cast here.

1177–1178

Please fold these lines together.

1196–1200

Please format this with clang-format.

1210

Please format this with clang-format.

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

667–676

That's a good point. I'm not sure I know all the implications of the various linkage options, but it sounds like PrivateLinkage is probably what we want here.

[rnk]

Some early feedback, I still need to look at mapLandingPadBlocks.

It looks like your analysis runs once per landing pad, so chained EH actions will still get visited twice. We might want to consider an up-front analysis on the whole function.

include/llvm/Transforms/Utils/Cloning.h

148–149

Can SkipInstruction do this also?

lib/CodeGen/WinEHPrepare.cpp

513–515

This can be just removeUnreachableBlocks(F). If we need more cleanup power, we can consider making simplifyFunctionCFG from lib/Transforms/Scalar/SimplifyCFGPass.cpp a utility.

898–904

Based on the comment, I think SimplifyCFG knows how to do this already. If you run SimplifyCFG() on each landing pad BB, you'll get the same behavior with none of this code.

You may need to run some other cleanup utility on the block first, though.

1111

Looks like you did that. :)

[andrew.w.kaylor]

include/llvm/Transforms/Utils/Cloning.h

148–149

I actually originally coded it that way, but it seemed to me like I was overloading the meaning of SkipInstruction too much. I don't have strong feelings about it either way.

lib/CodeGen/WinEHPrepare.cpp

513–515

Sounds good. By the way, I forgot to add a comment mentioning this, but this is currently deleting too much because the indirect branch targets aren't filled in in the revised landing pads.

898–904

I saw the SimplifyResume function in SimplifyCFG. It wouldn't work as is here because it only handles resumes in the same block as the landing pad instruction. I considered moving some form of the logic here into SimplifyResume, but I'm not sure it really belongs there.

The case this is meant to handle looks like this:

catch14:                                          ; preds = %catch.dispatch11
  %exn15 = load i8** %exn.slot
  %18 = call i8* @llvm.eh.begincatch(i8* %exn15) #4
  %19 = bitcast i8* %18 to float*
  %20 = load float* %19, align 4
  store float %20, float* %f, align 4
  %21 = load float* %f, align 4
  invoke void @_Z12handle_floatf(float %21)
          to label %invoke.cont17 unwind label %lpad16

lpad16:                                           ; preds = %catch14
  %22 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
          cleanup
  %23 = extractvalue { i8*, i32 } %22, 0
  store i8* %23, i8** %exn.slot
  %24 = extractvalue { i8*, i32 } %22, 1
  store i32 %24, i32* %ehselector.slot
  call void @llvm.eh.endcatch() #4
  br label %eh.resume

eh.resume:                                        ; preds = %lpad16, %catch.dispatch11
  %exn20 = load i8** %exn.slot
  %sel21 = load i32* %ehselector.slot
  %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn20, 0
  %lpad.val22 = insertvalue { i8*, i32 } %lpad.val, i32 %sel21, 1
  resume { i8*, i32 } %lpad.val22

This is the landing pad for an exception inside a catch handler, but in this case the landing pad doesn't do anything except continue the search. Since that happens automatically, we can just change the invoke in the catch handler to a call. But there are all kinds of things here that SimplifyResume doesn't know anything about.

There are two things here that make this not a candidate for simplification in SimplifyCFG. First, the fact that the endcatch call can be eliminated is very Windows specific. Second, the actual resume block is shared between two landing pads.

Arguably, we could teach SimplifyResume to identify the situations in which llvm.eh.endcatch can be dropped (currently always, but in the future maybe not). We'd also need to teach it how to consider multiple predecessors and decide which ones it can simplify.

[majnemer]

lib/CodeGen/WinEHPrepare.cpp

667–676

InternalLinkage is a bit nicer, it allows us to remove it if it becomes transitively unreferenced at link-time.

[rnk]

lib/CodeGen/WinEHPrepare.cpp

898–904

OK, this is specifically getting rid of unneeded llvm.eh.endcatch EH cleanups. Can we suppress this call to llvm.eh.endcatch in clang when using CxxFrameHandler3, or do we need it to stop outlining? If it doesn't help EH preparation, then it doesn't have much use.

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

898–904

Yeah, I guess you could say this is getting ride of the call to llvm.eh.endcatch since that's the only thing here that isn't scaffolding, but it also gets rid of the landing pad and turns an invoke into a call. The EH preparation doesn't need any of that.

I'd definitely like to have clang not omit code like this, but I think it still can turn out this way as a result of later optimizations. For instance, if there's a destructor to be called, clang would need to emit the invoke and cleanup, but if the object being destructed or even just the call to the destructor later gets eliminated then we're back in this situation, so I think WinEHPrepare needs to know how to do this.

[rnk]

I'll take another look at this once the cleanup patch lands, since the diff will shrink a bit.

lib/CodeGen/WinEHPrepare.cpp

898–904

If some pass introduces a landingpad like this and simplifycfg doesn't zap it, that sounds like a phase-ordering bug in the optimizer. Also, once we take llvm.eh.endcatch out of the picture, we can just call SimplifyCFG to do this cleanup for us.

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

898–904

Unless there's something in SimplifyCFG other than SimplifyResume that would do this, we'd need to enhance SimplifyResume as I describe above. Currently it won't simplify if it finds anything at all other than debug info intrinsics between the landingpad and the resume.

Also, it just occurred to me that you were probably asking if llvm.eh.endcatch can be completely eliminated in all cases. I think I'd have to say "no" to that. I'm relying on either llvm.eh.endcatch or a resume instruction to mark the end of handler code. Without llvm.eh.endcatch we can just branch into normal code with no reliable way to tell we're done.

[andrew.w.kaylor]

Rebased to incorporate the recently committed patches.
Refactored to eliminate duplicate code.
Updated the landingpad replacement to properly preserve exception argument variables and indirect branch targets.
Added a mapping scheme to eliminate duplicate parsing of blocks shared between landing pads.

[rnk]

Some thoughts. I'll try to write up a more precise proposal for llvm.eh.actions.

lib/CodeGen/WinEHPrepare.cpp

72–75

You should do this and call .clear() at the end of runOnFunction(). My understanding is that FunctionPasses aren't recreated before and after each function.

126–131

Can you throw in a comment about how normally we only ever see at most one of these per landingpad?

462

Maybe do:

if (!HandlersOutlined)
  continue;

469–471

Would you say this was the "EH state" that we talked about, or something else?

499–507

What happens if these instructions still have uses? I think we'll assert on this code for example:

lpad:
  %ehvals = landingpad
  %x = load i32* %x.ptr
  ... ; normal EH dispatch
catch.int:
  store i32 %x, i32* %x.ptr

I think a cleaner way to do this would be:

1. create a new basic block for the llvm.eh.actions call
2. assert that there are no phi nodes on the old landingpad block (EH preparation should've demoted them)
3. clone the LandingPadInst from the old one into the new one
4. set the unwind edge of all incoming invokes to the new landingpad
5. old landingpad is now trivially unreachable, allow removeUnreachableBlocks to do its thing

The advantage of this approach is that you never have to try to update the def-use graph.

556–570

Can you help me understand this case? Is it something like this?

void f() {
  HasCleanup o;
  int x = g(); // invoke value used in catch
  try {
    g();
  } catch (int) {
    use_x(x);
  }
}

I wonder if this is a bug in DemoteRegToStack that can be shown with opt -reg2mem.

625

Can this be simplified with PatternMatch::match()?

704–706

You might want StartBB->getFirstInsertionPt(). Also, consider this test case:

void use_it(int);
void g();
void f() {
  int g_calls = 0;
  try {
    g(); g_calls++;
    g(); g_calls++;
    g(); g_calls++;
  } catch (int) {
    use_it(g_calls);
  }
}

Using -O2, we get this interesting landingpad:

lpad:                                             ; preds = %invoke.cont1, %invoke.cont, %entry
  %g_calls.0 = phi i32 [ 2, %invoke.cont1 ], [ 1, %invoke.cont ], [ 0, %entry ]
  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
          catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)

We need to make sure that phi gets demoted. We can probably do something like assert(StartBB->begin() == StartBB()->getFirstNonPhi());

804–833

These two functions could be refactored to be parameterized over the vector of stores, either EHPtrStores of SelectorStores.

824–831

This seems like an unexpected side effect for a function called "isEHPtrLoad".

847–853

It's kind of amusing that the ehptr hasn't been used for anything yet... I wonder if there's any way to get MSVC to use the second argument to the catch handler.

974

I still don't think we need this. I'd rather hold off on committing this and experiment with making the llvm.eh.endcatch() cleanup non-exceptional.

1023

I'm OK doing this for now, this isn't true in general, so we should put a FIXME here. Consider something horrible like this:

void might_throw();
struct MyDtor {
  __forceinline ~MyDtor() {
    try { might_throw(); } catch (int) {}
  }
};
void f() {
  MyDtor o;
  might_throw();
}

After inlining, f will have a cleanup with an invoke in it.

test/CodeGen/WinEH/cppeh-inalloca.ll

68

Negative checks should generally try to be overly general, since small changes in the output can easily leave behind an extractvalue instruction that isn't named '%2', for example. In this case, I'd go for:

; CHECK-NOT: extractvalue { i8*, i32 }
; CHECK-NOT: br label

This basically says, there shouldn't be extractvalue or branches before we hit the llvm.eh.actions call.

test/CodeGen/WinEH/cppeh-nested-2.ll

51–52

Should be gone as of this morning

[andrew.w.kaylor]

I'll rebase to pull in your latest changes and clean this up as you've suggested.

So, do you think it's worth pushing this forward on this review, or would you rather I peel off a piece or two?

lib/CodeGen/WinEHPrepare.cpp

72–75

Yeah, I thought I had a reason for keeping the actions around, but after thinking about it some more, that isn't necessary.

126–131

Sure.

462

OK

469–471

Yes, this is EH state. I'll fix the name in the comment here.

499–507

Sounds good.

556–570

No, case you cite here doesn't do this.

The case this is meant to handle shows up in the cppeh-nonalloca-frame-values.ll test. Basically, any time a temporary value is computed in the normal code but only referenced in the catch code this happens. The source code for that test looks like this:

void test() {
  int NumExceptions = 0;
  int ExceptionVal[10];
  SomeData Data = { 0, 0 };

  for (int i = 0; i < 10; ++i) {
    try {
      may_throw();
      Data.a += i;
    }
    catch (int e) {
      ExceptionVal[NumExceptions] = e;
      ++NumExceptions;
      if (e == i)
        Data.b += e;
      else
        Data.a += e;
    }
    does_not_throw(NumExceptions);
  }
  dump(ExceptionVal, NumExceptions, Data);
}

The when this is compiled with optimization enabled, both i32 members of Data get initialized with a single i64 store. There's a GEP instruction in the entry block that gets the address of the 'b' memebr as %b, but %b is only used in the catch handling code.

What DemoteRegToStack is doing seems correct to me. If the value to be demoted has no uses then it just erases it and returns NULL. The trouble is caused by the fact that I'm doing this demotion after the catch handler code has been pruned. The only reference to the value was in the catch handler and the outlined handler is using a temporary alloca which is at this point waiting to be replaced by a framerecover call.

I think the right solution in this case is to sink the "computed" value into the catch handler. That could get a bit tricky in cases (probably very common) where values needed to by the value to be sunk aren't otherwise referenced in the handler, but I expect we can find a reasonable way to do it.

For instance in the case cited above, %b looks like this:

%b = getelementptr inbounds %struct.SomeData, %struct.SomeData* %tmpcast, i64 0, i32 1

Nothing in the catch handler references %tmpcast, so we'd need to pull it in. Right now we're creating a temporary alloca for %b in the value materializer and translating that to a framerecover call. I think if we recognize that %b is a non-alloca with no uses outside the catch handlers (I see this having the potential to go south here, but it would be easy enough for this case), then the materializer can create a temporary alloca for %tmpcast instead (if that hasn't been done already) and clone the %b instruction.

625

I'll look into that.

804–833

OK

824–831

Yeah, I should probably rename it. I'm pretty sure I've seen this kind of thing happening often in code generated with optimizations disabled.

847–853

Hard to say. It looks like it's just there to help out the debugger.

974

I'm fine with holding it back for now.

1023

I believe the MS runtime will terminate the process if an exception occurs in a cleanup handler. So I think we'd need to ignore the __forceinline attribute in that case.

test/CodeGen/WinEH/cppeh-inalloca.ll

68

Yeah, I was thinking about this yesterday as I was having to renumber temporary variables in some of the positive checks. These tests are probably going to be very brittle the way I've written them. At some point I want to go through and generalize them in a lot of ways. For now, I can certainly trim down the negative checks as you suggest.

test/CodeGen/WinEH/cppeh-nested-2.ll

51–52

Woo hoo!

[andrew.w.kaylor]

Incorporated feedback from previous review
Rebased to merge with latest trunk code
Abstracted value names in tests

[rnk]

I think this is pretty close.

lib/CodeGen/WinEHPrepare.cpp

1122–1123

I think if we can resolve this, it'll greatly simplify the code and reduce the amount of repeated selector analysis.

1290

Does this do anything?

1307–1310

Don't we need to analyze the condition more to know which BB is the fallthrough side?

1324–1328

This seems like a lot of work, we end up mapping the same landingpads over and over in inner loops. Maybe we should have a map for each landing pad and just look them up inside the cloning directors?

1342–1344

I feel like this repeated stanza could be simplified to something like:

return createCleanupHandler(CleanupHandlerMap, BB);

void createCleanupHandler(CleanupHandlerMapTy &Map, BasicBlock *BB) {
  auto *Action = new CleanupHandler(BB);
  Map[BB] = Action;
  return Action;
}

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

1122–1123

Actually I think what I meant by this comment is already accomplished by the new handling of the catch and cleanup maps.

1290

No. I have no idea why that's there.

1307–1310

I don't think so. I believe earlier analysis of this block has determined that the block ends with a branch that is either unconditional or is predicated on the comparison of the result of an llvm.eh.typeid.for call and that the predicate is either ICMP_EQ or ICMP_NE, so just looking at the predicate tells us which successor corresponds to a selector match.

If the predicate is ICMP_EQ, then successor 0 is the catch block and successor 1 is the fall through, otherwise the reverse.

I can add some more comments to explain this. I can probably also clean this up a bit with PatternMatch.

1324–1328

You're right. There's no reason to create more than one LandingPadMapper for each landing pad.

1342–1344

Sure. We can do that.

[andrew.w.kaylor]

Simplified cleanup handler mapping
Eliminated duplicate landing pad instruction mapping

[rnk]

David said he'd take a look, but this looks good to me.

I want to patch it in and see if I can parameterize this a bit to work for SEH __finally block outlining. Exciting. :)

test/CodeGen/WinEH/cppeh-nonalloca-frame-values.ll

236

FileCheck actually doesn't care about horizontal whitespace. A run of spaces and tabs will match any other run of spaces and tabs.

[majnemer]

LGTM

[andrew.w.kaylor]

This change set was implemented in r231981.

include/llvm/Transforms/Utils/Cloning.h

public:
   /// This enumeration describes the way CloneAndPruneIntoFromInst should
   /// proceed after the CloningDirector has examined an instruction.
   enum CloningAction {
     ///< Continue cloning the instruction (default behavior).
     CloneInstruction,
     ///< Skip this instruction but continue cloning the current basic block.
     SkipInstruction,
     ///< Skip this instruction and stop cloning the current basic block.
-    StopCloningBB
+    StopCloningBB,
+    ///< Don't clone the terminator but clone the current block's successors.
+    CloneSuccessors
   };
 
   virtual ~CloningDirector() {}
 
   /// Subclasses must override this function to customize cloning behavior.
   virtual CloningAction handleInstruction(ValueToValueMapTy &VMap,
                                           const Instruction *Inst,
                                           BasicBlock *NewBB) = 0;

lib/CodeGen/WinEHPrepare.cpp

 // backend wants. It snifs the personality function to see which kind of
 // preparation is necessary. If the personality function uses the Itanium LSDA,
 // this pass delegates to the DWARF EH preparation pass.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Analysis/LibCallSemantics.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <memory>
 
 using namespace llvm;
 using namespace llvm::PatternMatch;
 
 #define DEBUG_TYPE "winehprepare"
 
 namespace {
 
 // This map is used to model frame variable usage during outlining, to
 // construct a structure type to hold the frame variables in a frame
 // allocation block, and to remap the frame variable allocas (including
 // spill locations as needed) to GEPs that get the variable from the
 // frame allocation structure.
 typedef MapVector<Value *, TinyPtrVector<AllocaInst *>> FrameVarInfoMap;
 
+typedef SmallSet<BasicBlock *, 4> VisitedBlockSet;
+
+enum ActionType { Catch, Cleanup };
+
+class LandingPadActions;
+class ActionHandler;
+class CatchHandler;
+class CleanupHandler;
+class LandingPadMap;
+
+typedef DenseMap<const BasicBlock *, CatchHandler *> CatchHandlerMapTy;
+typedef DenseMap<const BasicBlock *, CleanupHandler *> CleanupHandlerMapTy;
+
 class WinEHPrepare : public FunctionPass {
   std::unique_ptr<FunctionPass> DwarfPrepare;
 
-  enum HandlerType { Catch, Cleanup };
-
 public:
   static char ID; // Pass identification, replacement for typeid.
   WinEHPrepare(const TargetMachine *TM = nullptr)
       : FunctionPass(ID), DwarfPrepare(createDwarfEHPass(TM)) {}
 
   bool runOnFunction(Function &Fn) override;
 
   bool doFinalization(Module &M) override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
   const char *getPassName() const override {
     return "Windows exception handling preparation";
   }
 
 private:
   bool prepareCPPEHHandlers(Function &F,
                             SmallVectorImpl<LandingPadInst *> &LPads);
-  bool outlineHandler(HandlerType CatchOrCleanup, Function *SrcFn,
-                      Constant *SelectorType, LandingPadInst *LPad,
+  bool outlineHandler(ActionHandler *Action, Function *SrcFn,
+                      LandingPadInst *LPad, BasicBlock *StartBB,
                       FrameVarInfoMap &VarInfo);
+
+  void mapLandingPadBlocks(LandingPadInst *LPad, LandingPadActions &Actions);
+  CatchHandler *findCatchHandler(BasicBlock *BB, BasicBlock *&NextBB,
+                                 VisitedBlockSet &VisitedBlocks);
+  CleanupHandler *findCleanupHandler(BasicBlock *StartBB, BasicBlock *EndBB);
+
+  CatchHandlerMapTy CatchHandlerMap;
+  CleanupHandlerMapTy CleanupHandlerMap;
+  DenseMap<const LandingPadInst *, LandingPadMap>  LPadMaps;
 };
 
 class WinEHFrameVariableMaterializer : public ValueMaterializer {
 public:
   WinEHFrameVariableMaterializer(Function *OutlinedFn,
                                  FrameVarInfoMap &FrameVarInfo);
   ~WinEHFrameVariableMaterializer() {}
 
   virtual Value *materializeValueFor(Value *V) override;
 
 private:
   FrameVarInfoMap &FrameVarInfo;
   IRBuilder<> Builder;
 };
 
+class LandingPadMap {
+public:
+  LandingPadMap() : OriginLPad(nullptr) {}
+  void mapLandingPad(const LandingPadInst *LPad);
+
+  bool isInitialized() { return OriginLPad != nullptr; }
+
+  bool mapIfEHPtrLoad(const LoadInst *Load) {
+    return mapIfEHLoad(Load, EHPtrStores, EHPtrStoreAddrs);
+  }
+  bool mapIfSelectorLoad(const LoadInst *Load) {
+    return mapIfEHLoad(Load, SelectorStores, SelectorStoreAddrs);
+  }
+
+  bool isLandingPadSpecificInst(const Instruction *Inst) const;
+
+  void remapSelector(ValueToValueMapTy &VMap, Value *MappedValue) const;
+
+private:
+  bool mapIfEHLoad(const LoadInst *Load,
+                   SmallVectorImpl<const StoreInst *> &Stores,
+                   SmallVectorImpl<const Value *> &StoreAddrs);
+
+  const LandingPadInst *OriginLPad;
+  // We will normally only see one of each of these instructions, but
+  // if more than one occurs for some reason we can handle that.
+  TinyPtrVector<const ExtractValueInst *> ExtractedEHPtrs;
+  TinyPtrVector<const ExtractValueInst *> ExtractedSelectors;
+
+  // In optimized code, there will typically be at most one instance of
+  // each of the following, but in unoptimized IR it is not uncommon
+  // for the values to be stored, loaded and then stored again.  In that
+  // case we will create a second entry for each store and store address.
+  SmallVector<const StoreInst *, 2> EHPtrStores;
+  SmallVector<const StoreInst *, 2> SelectorStores;
+  SmallVector<const Value *, 2> EHPtrStoreAddrs;
+  SmallVector<const Value *, 2> SelectorStoreAddrs;
+};
+
 class WinEHCloningDirectorBase : public CloningDirector {
 public:
-  WinEHCloningDirectorBase(LandingPadInst *LPI, Function *HandlerFn,
-                           FrameVarInfoMap &VarInfo)
-      : LPI(LPI), Materializer(HandlerFn, VarInfo),
-        SelectorIDType(Type::getInt32Ty(LPI->getContext())),
-        Int8PtrType(Type::getInt8PtrTy(LPI->getContext())),
-        ExtractedEHPtr(nullptr), ExtractedSelector(nullptr),
-        EHPtrStoreAddr(nullptr), SelectorStoreAddr(nullptr) {}
+  WinEHCloningDirectorBase(Function *HandlerFn,
+                           FrameVarInfoMap &VarInfo,
+                           LandingPadMap &LPadMap)
+      : Materializer(HandlerFn, VarInfo),
+        SelectorIDType(Type::getInt32Ty(HandlerFn->getContext())),
+        Int8PtrType(Type::getInt8PtrTy(HandlerFn->getContext())),
+        LPadMap(LPadMap) {}
 
   CloningAction handleInstruction(ValueToValueMapTy &VMap,
                                   const Instruction *Inst,
                                   BasicBlock *NewBB) override;
 
   virtual CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
                                          const Instruction *Inst,
                                          BasicBlock *NewBB) = 0;
   virtual CloningAction handleEndCatch(ValueToValueMapTy &VMap,
                                        const Instruction *Inst,
                                        BasicBlock *NewBB) = 0;
   virtual CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
                                         const Instruction *Inst,
                                         BasicBlock *NewBB) = 0;
+  virtual CloningAction handleInvoke(ValueToValueMapTy &VMap,
+                                     const InvokeInst *Invoke,
+                                     BasicBlock *NewBB) = 0;
   virtual CloningAction handleResume(ValueToValueMapTy &VMap,
                                      const ResumeInst *Resume,
                                      BasicBlock *NewBB) = 0;
 
   ValueMaterializer *getValueMaterializer() override { return &Materializer; }
 
 protected:
-  LandingPadInst *LPI;
   WinEHFrameVariableMaterializer Materializer;
   Type *SelectorIDType;
   Type *Int8PtrType;
-
-  const Value *ExtractedEHPtr;
-  const Value *ExtractedSelector;
-  const Value *EHPtrStoreAddr;
-  const Value *SelectorStoreAddr;
+  LandingPadMap &LPadMap;
 };
 
 class WinEHCatchDirector : public WinEHCloningDirectorBase {
 public:
-  WinEHCatchDirector(LandingPadInst *LPI, Function *CatchFn, Value *Selector,
-                     FrameVarInfoMap &VarInfo)
-      : WinEHCloningDirectorBase(LPI, CatchFn, VarInfo),
-        CurrentSelector(Selector->stripPointerCasts()) {}
+  WinEHCatchDirector(Function *CatchFn, Value *Selector,
+                     FrameVarInfoMap &VarInfo, LandingPadMap &LPadMap)
+      : WinEHCloningDirectorBase(CatchFn, VarInfo, LPadMap),
+        CurrentSelector(Selector->stripPointerCasts()),
+        ExceptionObjectVar(nullptr) {}
 
   CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
                                  const Instruction *Inst,
                                  BasicBlock *NewBB) override;
   CloningAction handleEndCatch(ValueToValueMapTy &VMap, const Instruction *Inst,
                                BasicBlock *NewBB) override;
   CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
                                 const Instruction *Inst,
                                 BasicBlock *NewBB) override;
+  CloningAction handleInvoke(ValueToValueMapTy &VMap, const InvokeInst *Invoke,
+                             BasicBlock *NewBB) override;
   CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst *Resume,
                              BasicBlock *NewBB) override;
 
+  const Value *getExceptionVar() { return ExceptionObjectVar; }
+  TinyPtrVector<BasicBlock *> &getReturnTargets() { return ReturnTargets; }
+
 private:
   Value *CurrentSelector;
+
+  const Value *ExceptionObjectVar;
+  TinyPtrVector<BasicBlock *> ReturnTargets;
 };
 
 class WinEHCleanupDirector : public WinEHCloningDirectorBase {
 public:
-  WinEHCleanupDirector(LandingPadInst *LPI, Function *CleanupFn,
-                       FrameVarInfoMap &VarInfo)
-      : WinEHCloningDirectorBase(LPI, CleanupFn, VarInfo) {}
+  WinEHCleanupDirector(Function *CleanupFn,
+                       FrameVarInfoMap &VarInfo, LandingPadMap &LPadMap)
+      : WinEHCloningDirectorBase(CleanupFn, VarInfo, LPadMap) {}
 
   CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
                                  const Instruction *Inst,
                                  BasicBlock *NewBB) override;
   CloningAction handleEndCatch(ValueToValueMapTy &VMap, const Instruction *Inst,
                                BasicBlock *NewBB) override;
   CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
                                 const Instruction *Inst,
                                 BasicBlock *NewBB) override;
+  CloningAction handleInvoke(ValueToValueMapTy &VMap, const InvokeInst *Invoke,
+                             BasicBlock *NewBB) override;
   CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst *Resume,
                              BasicBlock *NewBB) override;
 };
 
+class ActionHandler {
+public:
+  ActionHandler(BasicBlock *BB, ActionType Type)
+      : StartBB(BB), Type(Type), OutlinedFn(nullptr) {}
+
+  ActionType getType() const { return Type; }
+  BasicBlock *getStartBlock() const { return StartBB; }
+
+  bool hasBeenOutlined() { return OutlinedFn != nullptr; }
+
+  void setOutlinedFunction(Function *F) { OutlinedFn = F; }
+  Function *getOutlinedFunction() { return OutlinedFn; }
+
+private:
+  BasicBlock *StartBB;
+  ActionType Type;
+  Function *OutlinedFn;
+};
+
+class CatchHandler : public ActionHandler {
+public:
+  CatchHandler(BasicBlock *BB, Constant *Selector, BasicBlock *NextBB)
+      : Selector(Selector), NextBB(NextBB), ExceptionObjectVar(nullptr),
+        ActionHandler(BB, ActionType::Catch) {}
+
+  // Method for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const ActionHandler *H) {
+    return H->getType() == ActionType::Catch;
+  }
+
+  Constant *getSelector() const { return Selector; }
+  BasicBlock *getNextBB() const { return NextBB; }
+
+  const Value *getExceptionVar() { return ExceptionObjectVar; }
+  TinyPtrVector<BasicBlock *> &getReturnTargets() { return ReturnTargets; }
+
+  void setExceptionVar(const Value *Val) { ExceptionObjectVar = Val; }
+  void setReturnTargets(TinyPtrVector<BasicBlock *> &Targets) {
+    ReturnTargets = Targets;
+  }
+
+private:
+  Constant *Selector;
+  BasicBlock *NextBB;
+  const Value *ExceptionObjectVar;
+  TinyPtrVector<BasicBlock *> ReturnTargets;
+};
+
+class CleanupHandler : public ActionHandler {
+public:
+  CleanupHandler(BasicBlock *BB) : ActionHandler(BB, ActionType::Cleanup) {}
+
+  // Method for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const ActionHandler *H) {
+    return H->getType() == ActionType::Cleanup;
+  }
+};
+
+class LandingPadActions {
+public:
+  LandingPadActions() : HasCleanupHandlers(false) {}
+
+  void insertCatchHandler(CatchHandler *Action) { Actions.push_back(Action); }
+  void insertCleanupHandler(CleanupHandler *Action) {
+    Actions.push_back(Action);
+    HasCleanupHandlers = true;
+  }
+
+  bool includesCleanup() const { return HasCleanupHandlers; }
+
+  SmallVectorImpl<ActionHandler *>::iterator begin() { return Actions.begin(); }
+  SmallVectorImpl<ActionHandler *>::iterator end() { return Actions.end(); }
+
+private:
+  // Note that this class does not own the ActionHandler objects in this vector.
+  // The ActionHandlers are owned by the CatchHandlerMap and CleanupHandlerMap
+  // in the WinEHPrepare class.
+  SmallVector<ActionHandler *, 4> Actions;
+  bool HasCleanupHandlers;
+};
+
 } // end anonymous namespace
 
 char WinEHPrepare::ID = 0;
 INITIALIZE_TM_PASS_BEGIN(WinEHPrepare, "winehprepare",
                          "Prepare Windows exceptions", false, false)
 INITIALIZE_PASS_DEPENDENCY(DwarfEHPrepare)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)

 }
 
 bool WinEHPrepare::prepareCPPEHHandlers(
     Function &F, SmallVectorImpl<LandingPadInst *> &LPads) {
   // These containers are used to re-map frame variables that are used in
   // outlined catch and cleanup handlers.  They will be populated as the
   // handlers are outlined.
   FrameVarInfoMap FrameVarInfo;
 
   bool HandlersOutlined = false;
 
+  Module *M = F.getParent();
+  LLVMContext &Context = M->getContext();
+
+  // FIXME: Make this an intrinsic.
+  // Create a new function to receive the handler contents.
+  PointerType *Int8PtrType = Type::getInt8PtrTy(Context);
+  Type *Int32Type = Type::getInt32Ty(Context);
+  FunctionType *ActionTy = FunctionType::get(Int8PtrType, true);
+  Value *ActionIntrin = M->getOrInsertFunction("llvm.eh.actions", ActionTy);
+
   for (LandingPadInst *LPad : LPads) {
     // Look for evidence that this landingpad has already been processed.
     bool LPadHasActionList = false;
     BasicBlock *LPadBB = LPad->getParent();
     for (Instruction &Inst : LPadBB->getInstList()) {
       // FIXME: Make this an intrinsic.
-      if (auto *Call = dyn_cast<CallInst>(&Inst))
+      if (auto *Call = dyn_cast<CallInst>(&Inst)) {
         if (Call->getCalledFunction()->getName() == "llvm.eh.actions") {
           LPadHasActionList = true;
           break;
         }
       }
+      // FIXME: This is here to help with the development of nested landing pad
+      //        outlining.  It should be removed when that is finished.
+      if (isa<UnreachableInst>(Inst)) {
+        LPadHasActionList = true;
+        break;
+      }
+    }
 
     // If we've already outlined the handlers for this landingpad,
     // there's nothing more to do here.
     if (LPadHasActionList)
       continue;
 
-    for (unsigned Idx = 0, NumClauses = LPad->getNumClauses(); Idx < NumClauses;
-         ++Idx) {
-      if (LPad->isCatch(Idx)) {
-        // Create a new instance of the handler data structure in the
-        // HandlerData vector.
-        bool Outlined = outlineHandler(Catch, &F, LPad->getClause(Idx), LPad,
-                                       FrameVarInfo);
-        if (Outlined) {
-          HandlersOutlined = true;
-        }
-      } // End if (isCatch)
-    }   // End for each clause
+    LandingPadActions Actions;
+    mapLandingPadBlocks(LPad, Actions);
+
+    for (ActionHandler *Action : Actions) {
+      if (Action->hasBeenOutlined())
+        continue;
+      BasicBlock *StartBB = Action->getStartBlock();
+      if (outlineHandler(Action, &F, LPad, StartBB, FrameVarInfo)) {
+    } // End for each Action
 
-    // FIXME: This only handles the simple case where there is a 1:1
-    //        correspondence between landing pad and cleanup blocks.
-    //        It does not handle cases where there are catch blocks between
-    //        cleanup blocks or the case where a cleanup block is shared by
-    //        multiple landing pads.  Those cases will be supported later
-    //        when landing pad block analysis is added.
-    if (LPad->isCleanup()) {
-      bool Outlined =
-          outlineHandler(Cleanup, &F, nullptr, LPad, FrameVarInfo);
-      if (Outlined) {
-        HandlersOutlined = true;
+    // FIXME: We need a guard against partially outlined functions.
+    if (!HandlersOutlined)
+      continue;
+
+    // Replace the landing pad with a new llvm.eh.action based landing pad.
+    BasicBlock *NewLPadBB = BasicBlock::Create(Context, "lpad", &F, LPadBB);
+    assert(!isa<PHINode>(LPadBB->begin()));
+    Instruction *NewLPad = LPad->clone();
+    NewLPadBB->getInstList().push_back(NewLPad);
+    while (!pred_empty(LPadBB)) {
+      auto *pred = *pred_begin(LPadBB);
+      InvokeInst *Invoke = cast<InvokeInst>(pred->getTerminator());
+      Invoke->setUnwindDest(NewLPadBB);
+    }
+
+    // Add a call to describe the actions for this landing pad.
+    std::vector<Value *> ActionArgs;
+    ActionArgs.push_back(NewLPad);
+    for (ActionHandler *Action : Actions) {
+      if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
+        ActionArgs.push_back(ConstantInt::get(Int32Type, 0));
+        ActionArgs.push_back(CatchAction->getSelector());
+        Value *EHObj = const_cast<Value *>(CatchAction->getExceptionVar());
+        if (EHObj)
+          ActionArgs.push_back(EHObj);
+        else
+          ActionArgs.push_back(ConstantPointerNull::get(Int8PtrType));
+      } else {
+        ActionArgs.push_back(ConstantInt::get(Int32Type, 1));
+      }
+      Constant *HandlerPtr =
+          ConstantExpr::getBitCast(Action->getOutlinedFunction(), Int8PtrType);
+      ActionArgs.push_back(HandlerPtr);
+    }
+    CallInst *Recover =
+        CallInst::Create(ActionIntrin, ActionArgs, "recover", NewLPadBB);
+
+    // Add an indirect branch listing possible successors of the catch handlers.
+    IndirectBrInst *Branch = IndirectBrInst::Create(Recover, 0, NewLPadBB);
+    for (ActionHandler *Action : Actions) {
+      if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
+        for (auto *Target : CatchAction->getReturnTargets()) {
+          Branch->addDestination(Target);
+        }
       }
     }
   } // End for each landingpad
 
   // If nothing got outlined, there is no more processing to be done.
   if (!HandlersOutlined)
     return false;
 
-  // FIXME: We will replace the landingpad bodies with llvm.eh.actions
-  //        calls and indirect branches here and then delete blocks
-  //        which are no longer reachable.  That will get rid of the
-  //        handlers that we have outlined.  There is code below
-  //        that looks for allocas with no uses in the parent function.
-  //        That will only happen after the pruning is implemented.
+  // Delete any blocks that were only used by handlers that were outlined above.
+  removeUnreachableBlocks(F);
 
-  Module *M = F.getParent();
-  LLVMContext &Context = M->getContext();
   BasicBlock *Entry = &F.getEntryBlock();
   IRBuilder<> Builder(F.getParent()->getContext());
   Builder.SetInsertPoint(Entry->getFirstInsertionPt());
 
   Function *FrameEscapeFn =
       Intrinsic::getDeclaration(M, Intrinsic::frameescape);
   Function *RecoverFrameFn =
       Intrinsic::getDeclaration(M, Intrinsic::framerecover);
-  Type *Int8PtrType = Type::getInt8PtrTy(Context);
-  Type *Int32Type = Type::getInt32Ty(Context);
 
   // Finally, replace all of the temporary allocas for frame variables used in
   // the outlined handlers with calls to llvm.framerecover.
   BasicBlock::iterator II = Entry->getFirstInsertionPt();
   Instruction *AllocaInsertPt = II;
   SmallVector<Value *, 8> AllocasToEscape;
   for (auto &VarInfoEntry : FrameVarInfo) {
     Value *ParentVal = VarInfoEntry.first;
     TinyPtrVector<AllocaInst *> &Allocas = VarInfoEntry.second;
 
     // If the mapped value isn't already an alloca, we need to spill it if it
     // is a computed value or copy it if it is an argument.
     AllocaInst *ParentAlloca = dyn_cast<AllocaInst>(ParentVal);
     if (!ParentAlloca) {
       if (auto *Arg = dyn_cast<Argument>(ParentVal)) {
         // Lower this argument to a copy and then demote that to the stack.
         // We can't just use the argument location because the handler needs
         // it to be in the frame allocation block.
         // Use 'select i8 true, %arg, undef' to simulate a 'no-op' instruction.
         Value *TrueValue = ConstantInt::getTrue(Context);
         Value *UndefValue = UndefValue::get(Arg->getType());
         Instruction *SI =
             SelectInst::Create(TrueValue, Arg, UndefValue,
                                Arg->getName() + ".tmp", AllocaInsertPt);
         Arg->replaceAllUsesWith(SI);
         // Reset the select operand, because it was clobbered by the RAUW above.
         SI->setOperand(1, Arg);
         ParentAlloca = DemoteRegToStack(*SI, true, SI);
       } else if (auto *PN = dyn_cast<PHINode>(ParentVal)) {
         ParentAlloca = DemotePHIToStack(PN, AllocaInsertPt);
       } else {
         Instruction *ParentInst = cast<Instruction>(ParentVal);
+        // FIXME: This is a work-around to temporarily handle the case where an
+        //        instruction that is only used in handlers is not sunk.
+        //        Without uses, DemoteRegToStack would just eliminate the value.
+        //        This will fail if ParentInst is an invoke.
+        if (ParentInst->getNumUses() == 0) {
+          BasicBlock::iterator InsertPt = ParentInst;
+          ++InsertPt;
+          ParentAlloca =
+              new AllocaInst(ParentInst->getType(), nullptr,
+                             ParentInst->getName() + ".reg2mem", InsertPt);
+          new StoreInst(ParentInst, ParentAlloca, InsertPt);
+        } else {
           ParentAlloca = DemoteRegToStack(*ParentInst, true, ParentInst);
         }
       }
+    }
 
     // If the parent alloca is no longer used and only one of the handlers used
     // it, erase the parent and leave the copy in the outlined handler.
     if (ParentAlloca->getNumUses() == 0 && Allocas.size() == 1) {
       ParentAlloca->eraseFromParent();
       continue;
     }
 
     // Add this alloca to the list of things to escape.
     AllocasToEscape.push_back(ParentAlloca);
 
     // Next replace all outlined allocas that are mapped to it.
     for (AllocaInst *TempAlloca : Allocas) {
       Function *HandlerFn = TempAlloca->getParent()->getParent();
       // FIXME: Sink this GEP into the blocks where it is used.
       Builder.SetInsertPoint(TempAlloca);
       Builder.SetCurrentDebugLocation(TempAlloca->getDebugLoc());
       Value *RecoverArgs[] = {
           Builder.CreateBitCast(&F, Int8PtrType, ""),
           &(HandlerFn->getArgumentList().back()),
           llvm::ConstantInt::get(Int32Type, AllocasToEscape.size() - 1)};
-      Value *RecoveredAlloca =
-          Builder.CreateCall(RecoverFrameFn, RecoverArgs);
+      Value *RecoveredAlloca = Builder.CreateCall(RecoverFrameFn, RecoverArgs);
       // Add a pointer bitcast if the alloca wasn't an i8.
       if (RecoveredAlloca->getType() != TempAlloca->getType()) {
         RecoveredAlloca->setName(Twine(TempAlloca->getName()) + ".i8");
         RecoveredAlloca =
             Builder.CreateBitCast(RecoveredAlloca, TempAlloca->getType());
       }
       TempAlloca->replaceAllUsesWith(RecoveredAlloca);
       TempAlloca->removeFromParent();
       RecoveredAlloca->takeName(TempAlloca);
       delete TempAlloca;
     }
-  }   // End for each FrameVarInfo entry.
+  } // End for each FrameVarInfo entry.
 
   // Insert 'call void (...)* @llvm.frameescape(...)' at the end of the entry
   // block.
   Builder.SetInsertPoint(&F.getEntryBlock().back());
   Builder.CreateCall(FrameEscapeFn, AllocasToEscape);
 
+  // Clean up the handler action maps we created for this function
+  DeleteContainerSeconds(CatchHandlerMap);
+  CatchHandlerMap.clear();
+  DeleteContainerSeconds(CleanupHandlerMap);
+  CleanupHandlerMap.clear();
+
   return HandlersOutlined;
 }
 
-bool WinEHPrepare::outlineHandler(HandlerType CatchOrCleanup, Function *SrcFn,
-                                  Constant *SelectorType, LandingPadInst *LPad,
+// This function examines a block to determine whether the block ends with a
+// conditional branch to a catch handler based on a selector comparison.
+// This function is used both by the WinEHPrepare::findSelectorComparison() and
+// WinEHCleanupDirector::handleTypeIdFor().
+static bool isSelectorDispatch(BasicBlock *BB, BasicBlock *&CatchHandler,
+                               Constant *&Selector, BasicBlock *&NextBB) {
+  ICmpInst::Predicate Pred;
+  BasicBlock *TBB, *FBB;
+  Value *LHS, *RHS;
+
+  if (!match(BB->getTerminator(),
+             m_Br(m_ICmp(Pred, m_Value(LHS), m_Value(RHS)), TBB, FBB)))
+    return false;
+
+  if (!match(LHS,
+             m_Intrinsic<Intrinsic::eh_typeid_for>(m_Constant(Selector))) &&
+      !match(RHS, m_Intrinsic<Intrinsic::eh_typeid_for>(m_Constant(Selector))))
+    return false;
+
+  if (Pred == CmpInst::ICMP_EQ) {
+    CatchHandler = TBB;
+    NextBB = FBB;
+    return true;
+  }
+
+  if (Pred == CmpInst::ICMP_NE) {
+    CatchHandler = FBB;
+    NextBB = TBB;
+    return true;
+  }
+
+  return false;
+}
+
+bool WinEHPrepare::outlineHandler(ActionHandler *Action, Function *SrcFn,
+                                  LandingPadInst *LPad, BasicBlock *StartBB,
                                   FrameVarInfoMap &VarInfo) {
   Module *M = SrcFn->getParent();
   LLVMContext &Context = M->getContext();
 
   // Create a new function to receive the handler contents.
   Type *Int8PtrType = Type::getInt8PtrTy(Context);
   std::vector<Type *> ArgTys;
   ArgTys.push_back(Int8PtrType);
   ArgTys.push_back(Int8PtrType);
   Function *Handler;
-  if (CatchOrCleanup == Catch) {
+  if (Action->getType() == Catch) {
     FunctionType *FnType = FunctionType::get(Int8PtrType, ArgTys, false);
     Handler = Function::Create(FnType, GlobalVariable::InternalLinkage,
                                SrcFn->getName() + ".catch", M);
   } else {
     FunctionType *FnType =
         FunctionType::get(Type::getVoidTy(Context), ArgTys, false);
     Handler = Function::Create(FnType, GlobalVariable::InternalLinkage,
                                SrcFn->getName() + ".cleanup", M);
   }
 
   // Generate a standard prolog to setup the frame recovery structure.
   IRBuilder<> Builder(Context);
   BasicBlock *Entry = BasicBlock::Create(Context, "entry");
   Handler->getBasicBlockList().push_front(Entry);
   Builder.SetInsertPoint(Entry);
   Builder.SetCurrentDebugLocation(LPad->getDebugLoc());
 
   std::unique_ptr<WinEHCloningDirectorBase> Director;
 
-  if (CatchOrCleanup == Catch) {
+  ValueToValueMapTy VMap;
+
+  LandingPadMap &LPadMap = LPadMaps[LPad];
+  if (!LPadMap.isInitialized())
+    LPadMap.mapLandingPad(LPad);
+  if (Action->getType() == Catch) {
+    Constant *SelectorType = cast<CatchHandler>(Action)->getSelector();
     Director.reset(
-        new WinEHCatchDirector(LPad, Handler, SelectorType, VarInfo));
+        new WinEHCatchDirector(Handler, SelectorType, VarInfo, LPadMap));
+    LPadMap.remapSelector(VMap, ConstantInt::get( Type::getInt32Ty(Context), 1));
   } else {
-    Director.reset(new WinEHCleanupDirector(LPad, Handler, VarInfo));
+    Director.reset(new WinEHCleanupDirector(Handler, VarInfo, LPadMap));
   }
 
-  ValueToValueMapTy VMap;
-
-  // FIXME: Map other values referenced in the filter handler.
-
   SmallVector<ReturnInst *, 8> Returns;
-  ClonedCodeInfo InlinedFunctionInfo;
+  ClonedCodeInfo OutlinedFunctionInfo;
 
-  BasicBlock::iterator II = LPad;
+  // Skip over PHIs and, if applicable, landingpad instructions.
+  BasicBlock::iterator II = StartBB->getFirstInsertionPt();
 
-  CloneAndPruneIntoFromInst(Handler, SrcFn, ++II, VMap,
+  CloneAndPruneIntoFromInst(Handler, SrcFn, II, VMap,
                             /*ModuleLevelChanges=*/false, Returns, "",
-                            &InlinedFunctionInfo, Director.get());
+                            &OutlinedFunctionInfo, Director.get());
 
   // Move all the instructions in the first cloned block into our entry block.
   BasicBlock *FirstClonedBB = std::next(Function::iterator(Entry));
   Entry->getInstList().splice(Entry->end(), FirstClonedBB->getInstList());
   FirstClonedBB->eraseFromParent();
 
+  if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
+    WinEHCatchDirector *CatchDirector =
+        reinterpret_cast<WinEHCatchDirector *>(Director.get());
+    CatchAction->setExceptionVar(CatchDirector->getExceptionVar());
+    CatchAction->setReturnTargets(CatchDirector->getReturnTargets());
+  }
+
+  Action->setOutlinedFunction(Handler);
+
   return true;
 }
 
-CloningDirector::CloningAction WinEHCloningDirectorBase::handleInstruction(
-    ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
-  // Intercept instructions which extract values from the landing pad aggregate.
-  if (auto *Extract = dyn_cast<ExtractValueInst>(Inst)) {
-    if (Extract->getAggregateOperand() == LPI) {
-      assert(Extract->getNumIndices() == 1 &&
-             "Unexpected operation: extracting both landing pad values");
-      assert((*(Extract->idx_begin()) == 0 || *(Extract->idx_begin()) == 1) &&
-             "Unexpected operation: extracting an unknown landing pad element");
-
-      if (*(Extract->idx_begin()) == 0) {
-        // Element 0 doesn't directly corresponds to anything in the WinEH
-        // scheme.
-        // It will be stored to a memory location, then later loaded and finally
-        // the loaded value will be used as the argument to an
-        // llvm.eh.begincatch
-        // call.  We're tracking it here so that we can skip the store and load.
-        ExtractedEHPtr = Inst;
-      } else {
-        // Element 1 corresponds to the filter selector.  We'll map it to 1 for
-        // matching purposes, but it will also probably be stored to memory and
-        // reloaded, so we need to track the instuction so that we can map the
-        // loaded value too.
-        VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
-        ExtractedSelector = Inst;
-      }
+void LandingPadMap::mapLandingPad(const LandingPadInst *LPad) {
+  // Each instance of this class should only ever be used to map a single
+  // landing pad.
+  assert(OriginLPad == nullptr || OriginLPad == LPad);
+
+  // If the landing pad has already been mapped, there's nothing more to do.
+  if (OriginLPad == LPad)
+    return;
+
+  OriginLPad = LPad;
+
+  // The landingpad instruction returns an aggregate value.  Typically, its
+  // value will be passed to a pair of extract value instructions and the
+  // results of those extracts are often passed to store instructions.
+  // In unoptimized code the stored value will often be loaded and then stored
+  // again.
+  for (auto *U : LPad->users()) {
+    const ExtractValueInst *Extract = dyn_cast<ExtractValueInst>(U);
+    if (!Extract)
+      continue;
+    unsigned int Idx = *(Extract->idx_begin());
+    assert((Idx == 0 || Idx == 1) &&
+    if (Idx == 0) {
+      ExtractedEHPtrs.push_back(Extract);
+    } else if (Idx == 1) {
+      ExtractedSelectors.push_back(Extract);
 
-      // Tell the caller not to clone this instruction.
-      return CloningDirector::SkipInstruction;
-    }
-    // Other extract value instructions just get cloned.
-    return CloningDirector::CloneInstruction;
-  }
+    // Look for stores of the extracted values.
+    for (auto *EU : Extract->users()) {
+      if (auto *Store = dyn_cast<StoreInst>(EU)) {
+        if (Idx == 1) {
+          SelectorStores.push_back(Store);
+          SelectorStoreAddrs.push_back(Store->getPointerOperand());
+        } else {
+          EHPtrStores.push_back(Store);
+          EHPtrStoreAddrs.push_back(Store->getPointerOperand());
+        }
+      }
+    }
 
-  if (auto *Store = dyn_cast<StoreInst>(Inst)) {
-    // Look for and suppress stores of the extracted landingpad values.
-    const Value *StoredValue = Store->getValueOperand();
-    if (StoredValue == ExtractedEHPtr) {
-      EHPtrStoreAddr = Store->getPointerOperand();
-      return CloningDirector::SkipInstruction;
-    }
-    if (StoredValue == ExtractedSelector) {
-      SelectorStoreAddr = Store->getPointerOperand();
-      return CloningDirector::SkipInstruction;
-    }
+bool LandingPadMap::isLandingPadSpecificInst(const Instruction *Inst) const {
+  if (Inst == OriginLPad)
+    return true;
+  for (auto *Extract : ExtractedEHPtrs) {
+    if (Inst == Extract)
+      return true;
+  for (auto *Extract : ExtractedSelectors) {
+    if (Inst == Extract)
+      return true;
+  }
+  for (auto *Store : EHPtrStores) {
+    if (Inst == Store)
+      return true;
+  }
+  for (auto *Store : SelectorStores) {
+    if (Inst == Store)
+      return true;
 
-    // Any other store just gets cloned.
-    return CloningDirector::CloneInstruction;
-  }
+  return false;
 
+void LandingPadMap::remapSelector(ValueToValueMapTy &VMap,
+                                     Value *MappedValue) const {
+  // Remap all selector extract instructions to the specified value.
+  for (auto *Extract : ExtractedSelectors)
+    VMap[Extract] = MappedValue;
+}
+
+bool LandingPadMap::mapIfEHLoad(const LoadInst *Load,
+                                   SmallVectorImpl<const StoreInst *> &Stores,
+                                   SmallVectorImpl<const Value *> &StoreAddrs) {
+  // This makes the assumption that a store we've previously seen dominates
+  // this load instruction.  That might seem like a rather huge assumption,
+  // but given the way that landingpads are constructed its fairly safe.
+  // FIXME: Add debug/assert code that verifies this.
+  const Value *LoadAddr = Load->getPointerOperand();
+  for (auto *StoreAddr : StoreAddrs) {
+    if (LoadAddr == StoreAddr) {
+      // Handle the common debug scenario where this loaded value is stored
+      // to a different location.
+      for (auto *U : Load->users()) {
+        if (auto *Store = dyn_cast<StoreInst>(U)) {
+          Stores.push_back(Store);
+          StoreAddrs.push_back(Store->getPointerOperand());
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+CloningDirector::CloningAction WinEHCloningDirectorBase::handleInstruction(
+    ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
+  // If this is one of the boilerplate landing pad instructions, skip it.
+  // The instruction will have already been remapped in VMap.
+  if (LPadMap.isLandingPadSpecificInst(Inst))
+    return CloningDirector::SkipInstruction;
+
   if (auto *Load = dyn_cast<LoadInst>(Inst)) {
     // Look for loads of (previously suppressed) landingpad values.
-    // The EHPtr load can be ignored (it should only be used as
-    // an argument to llvm.eh.begincatch), but the selector value
-    // needs to be mapped to a constant value of 1 to be used to
-    // simplify the branching to always flow to the current handler.
-    const Value *LoadAddr = Load->getPointerOperand();
-    if (LoadAddr == EHPtrStoreAddr) {
-      VMap[Inst] = UndefValue::get(Int8PtrType);
+    // The EHPtr load can be mapped to an undef value as it should only be used
+    // as an argument to llvm.eh.begincatch, but the selector value needs to be
+    // mapped to a constant value of 1.  This value will be used to simplify the
+    // branching to always flow to the current handler.
+    if (LPadMap.mapIfSelectorLoad(Load)) {
+      VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
       return CloningDirector::SkipInstruction;
     }
-    if (LoadAddr == SelectorStoreAddr) {
-      VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
+    if (LPadMap.mapIfEHPtrLoad(Load)) {
+      VMap[Inst] = UndefValue::get(Int8PtrType);
       return CloningDirector::SkipInstruction;
     }
 
     // Any other loads just get cloned.
     return CloningDirector::CloneInstruction;
   }
 
+  // Nested landing pads will be cloned as stubs, with just the
+  // landingpad instruction and an unreachable instruction. When
+  // all landingpads have been outlined, we'll replace this with the
+  // llvm.eh.actions call and indirect branch created when the
+  // landing pad was outlined.
+  if (auto *NestedLPad = dyn_cast<LandingPadInst>(Inst)) {
+    Instruction *NewInst = NestedLPad->clone();
+    if (NestedLPad->hasName())
+      NewInst->setName(NestedLPad->getName());
+    // FIXME: Store this mapping somewhere else also.
+    VMap[NestedLPad] = NewInst;
+    BasicBlock::InstListType &InstList = NewBB->getInstList();
+    InstList.push_back(NewInst);
+    InstList.push_back(new UnreachableInst(NewBB->getContext()));
+    return CloningDirector::StopCloningBB;
+  }
+
+  if (auto *Invoke = dyn_cast<InvokeInst>(Inst))
+    return handleInvoke(VMap, Invoke, NewBB);
+
   if (auto *Resume = dyn_cast<ResumeInst>(Inst))
     return handleResume(VMap, Resume, NewBB);
 
   if (match(Inst, m_Intrinsic<Intrinsic::eh_begincatch>()))
     return handleBeginCatch(VMap, Inst, NewBB);
   if (match(Inst, m_Intrinsic<Intrinsic::eh_endcatch>()))
     return handleEndCatch(VMap, Inst, NewBB);
   if (match(Inst, m_Intrinsic<Intrinsic::eh_typeid_for>()))
     return handleTypeIdFor(VMap, Inst, NewBB);
 
   // Continue with the default cloning behavior.
   return CloningDirector::CloneInstruction;
 }
 
 CloningDirector::CloningAction WinEHCatchDirector::handleBeginCatch(
     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
   // The argument to the call is some form of the first element of the
   // landingpad aggregate value, but that doesn't matter.  It isn't used
   // here.
   // The second argument is an outparameter where the exception object will be
   // stored. Typically the exception object is a scalar, but it can be an
   // aggregate when catching by value.
   // FIXME: Leave something behind to indicate where the exception object lives
   // for this handler. Should it be part of llvm.eh.actions?
+  assert(ExceptionObjectVar == nullptr && "Multiple calls to "
+                                          "llvm.eh.begincatch found while "
+                                          "outlining catch handler.");
+  ExceptionObjectVar = Inst->getOperand(1)->stripPointerCasts();
   return CloningDirector::SkipInstruction;
 }
 
 CloningDirector::CloningAction
 WinEHCatchDirector::handleEndCatch(ValueToValueMapTy &VMap,
                                    const Instruction *Inst, BasicBlock *NewBB) {
   auto *IntrinCall = dyn_cast<IntrinsicInst>(Inst);
   // It might be interesting to track whether or not we are inside a catch
   // function, but that might make the algorithm more brittle than it needs
   // to be.
 
   // The end catch call can occur in one of two places: either in a
-  // landingpad
-  // block that is part of the catch handlers exception mechanism, or at the
-  // end of the catch block.  If it occurs in a landing pad, we must skip it
-  // and continue so that the landing pad gets cloned.
+  // landingpad block that is part of the catch handlers exception mechanism,
+  // or at the end of the catch block.  If it occurs in a landing pad, we must
+  // skip it and continue so that the landing pad gets cloned.
   // FIXME: This case isn't fully supported yet and shouldn't turn up in any
   //        of the test cases until it is.
   if (IntrinCall->getParent()->isLandingPad())
     return CloningDirector::SkipInstruction;
 
   // If an end catch occurs anywhere else the next instruction should be an
   // unconditional branch instruction that we want to replace with a return
   // to the the address of the branch target.
   const BasicBlock *EndCatchBB = IntrinCall->getParent();
   const TerminatorInst *Terminator = EndCatchBB->getTerminator();
   const BranchInst *Branch = dyn_cast<BranchInst>(Terminator);
   assert(Branch && Branch->isUnconditional());
   assert(std::next(BasicBlock::const_iterator(IntrinCall)) ==
          BasicBlock::const_iterator(Branch));
 
-  ReturnInst::Create(NewBB->getContext(),
-                     BlockAddress::get(Branch->getSuccessor(0)), NewBB);
+  BasicBlock *ContinueLabel = Branch->getSuccessor(0);
+  ReturnInst::Create(NewBB->getContext(), BlockAddress::get(ContinueLabel),
+                     NewBB);
+  ReturnTargets.push_back(ContinueLabel);
 
   // We just added a terminator to the cloned block.
   // Tell the caller to stop processing the current basic block so that
   // the branch instruction will be skipped.
   return CloningDirector::StopCloningBB;
 }
 
 CloningDirector::CloningAction WinEHCatchDirector::handleTypeIdFor(
     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
   auto *IntrinCall = dyn_cast<IntrinsicInst>(Inst);
   Value *Selector = IntrinCall->getArgOperand(0)->stripPointerCasts();
   // This causes a replacement that will collapse the landing pad CFG based
   // on the filter function we intend to match.
   if (Selector == CurrentSelector)
     VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
   else
     VMap[Inst] = ConstantInt::get(SelectorIDType, 0);
   // Tell the caller not to clone this instruction.
   return CloningDirector::SkipInstruction;
 }
 
 CloningDirector::CloningAction
+WinEHCatchDirector::handleInvoke(ValueToValueMapTy &VMap,
+                                 const InvokeInst *Invoke, BasicBlock *NewBB) {
+  return CloningDirector::CloneInstruction;
+}
+
+CloningDirector::CloningAction
 WinEHCatchDirector::handleResume(ValueToValueMapTy &VMap,
                                  const ResumeInst *Resume, BasicBlock *NewBB) {
   // Resume instructions shouldn't be reachable from catch handlers.
   // We still need to handle it, but it will be pruned.
   BasicBlock::InstListType &InstList = NewBB->getInstList();
   InstList.push_back(new UnreachableInst(NewBB->getContext()));
   return CloningDirector::StopCloningBB;
 }
 
 CloningDirector::CloningAction WinEHCleanupDirector::handleBeginCatch(
     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
   // Catch blocks within cleanup handlers will always be unreachable.
   // We'll insert an unreachable instruction now, but it will be pruned
   // before the cloning process is complete.
   BasicBlock::InstListType &InstList = NewBB->getInstList();
   InstList.push_back(new UnreachableInst(NewBB->getContext()));
   return CloningDirector::StopCloningBB;
 }
 
 CloningDirector::CloningAction WinEHCleanupDirector::handleEndCatch(
     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
   // Catch blocks within cleanup handlers will always be unreachable.
   // We'll insert an unreachable instruction now, but it will be pruned
   // before the cloning process is complete.
   BasicBlock::InstListType &InstList = NewBB->getInstList();
   InstList.push_back(new UnreachableInst(NewBB->getContext()));
   return CloningDirector::StopCloningBB;
 }
 
 CloningDirector::CloningAction WinEHCleanupDirector::handleTypeIdFor(
     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
-  // This causes a replacement that will collapse the landing pad CFG
-  // to just the cleanup code.
+  // If we encounter a selector comparison while cloning a cleanup handler,
+  // we want to stop cloning immediately.  Anything after the dispatch
+  // will be outlined into a different handler.
+  BasicBlock *CatchHandler;
+  Constant *Selector;
+  BasicBlock *NextBB;
+  if (isSelectorDispatch(const_cast<BasicBlock *>(Inst->getParent()),
+                         CatchHandler, Selector, NextBB)) {
+    ReturnInst::Create(NewBB->getContext(), nullptr, NewBB);
+    return CloningDirector::StopCloningBB;
+  }
+  // If eg.typeid.for is called for any other reason, it can be ignored.
   VMap[Inst] = ConstantInt::get(SelectorIDType, 0);
-  // Tell the caller not to clone this instruction.
   return CloningDirector::SkipInstruction;
 }
 
+CloningDirector::CloningAction WinEHCleanupDirector::handleInvoke(
+    ValueToValueMapTy &VMap, const InvokeInst *Invoke, BasicBlock *NewBB) {
+  // All invokes in cleanup handlers can be replaced with calls.
+  SmallVector<Value *, 16> CallArgs(Invoke->op_begin(), Invoke->op_end() - 3);
+  // Insert a normal call instruction...
+  CallInst *NewCall =
+      CallInst::Create(const_cast<Value *>(Invoke->getCalledValue()), CallArgs,
+                       Invoke->getName(), NewBB);
+  NewCall->setCallingConv(Invoke->getCallingConv());
+  NewCall->setAttributes(Invoke->getAttributes());
+  NewCall->setDebugLoc(Invoke->getDebugLoc());
+  VMap[Invoke] = NewCall;
+
+  // Insert an unconditional branch to the normal destination.
+  BranchInst::Create(Invoke->getNormalDest(), NewBB);
+
+  // The unwind destination won't be cloned into the new function, so
+  // we don't need to clean up its phi nodes.
+
+  // We just added a terminator to the cloned block.
+  // Tell the caller to stop processing the current basic block.
+  return CloningDirector::StopCloningBB;
+}
+
 CloningDirector::CloningAction WinEHCleanupDirector::handleResume(
     ValueToValueMapTy &VMap, const ResumeInst *Resume, BasicBlock *NewBB) {
   ReturnInst::Create(NewBB->getContext(), nullptr, NewBB);
 
   // We just added a terminator to the cloned block.
   // Tell the caller to stop processing the current basic block so that
   // the branch instruction will be skipped.
   return CloningDirector::StopCloningBB;
 }
 
 WinEHFrameVariableMaterializer::WinEHFrameVariableMaterializer(
     Function *OutlinedFn, FrameVarInfoMap &FrameVarInfo)
     : FrameVarInfo(FrameVarInfo), Builder(OutlinedFn->getContext()) {
   Builder.SetInsertPoint(&OutlinedFn->getEntryBlock());
-  // FIXME: Do something with the FrameVarMapped so that it is shared across the
-  // function.
 }
 
 Value *WinEHFrameVariableMaterializer::materializeValueFor(Value *V) {
   // If we're asked to materialize a value that is an instruction, we
   // temporarily create an alloca in the outlined function and add this
   // to the FrameVarInfo map.  When all the outlining is complete, we'll
   // collect these into a structure, spilling non-alloca values in the
   // parent frame as necessary, and replace these temporary allocas with
if (isa<Instruction>(V) || isa<Argument>(V)) {
     FrameVarInfo[V].push_back(NewAlloca);
     LoadInst *NewLoad = Builder.CreateLoad(NewAlloca, V->getName() + ".reload");
     return NewLoad;
   }
 
   // Don't materialize other values.
   return nullptr;
 }
+
+// This function maps the catch and cleanup handlers that are reachable from the
+// specified landing pad. The landing pad sequence will have this basic shape:
+//
+//  <cleanup handler>
+//  <selector comparison>
+//  <catch handler>
+//  <cleanup handler>
+//  <selector comparison>
+//  <catch handler>
+//  <cleanup handler>
+//  ...
+//
+// Any of the cleanup slots may be absent.  The cleanup slots may be occupied by
+// any arbitrary control flow, but all paths through the cleanup code must
+// eventually reach the next selector comparison and no path can skip to a
+// different selector comparisons, though some paths may terminate abnormally.
+// Therefore, we will use a depth first search from the start of any given
+// cleanup block and stop searching when we find the next selector comparison.
+//
+// If the landingpad instruction does not have a catch clause, we will assume
+// that any instructions other than selector comparisons and catch handlers can
+// be ignored.  In practice, these will only be the boilerplate instructions.
+//
+// The catch handlers may also have any control structure, but we are only
+// interested in the start of the catch handlers, so we don't need to actually
+// follow the flow of the catch handlers.  The start of the catch handlers can
+// be located from the compare instructions, but they can be skipped in the
+// flow by following the contrary branch.
+void WinEHPrepare::mapLandingPadBlocks(LandingPadInst *LPad,
+                                       LandingPadActions &Actions) {
+  unsigned int NumClauses = LPad->getNumClauses();
+  unsigned int HandlersFound = 0;
+  BasicBlock *BB = LPad->getParent();
+
+  DEBUG(dbgs() << "Mapping landing pad: " << BB->getName() << "\n");
+
+  if (NumClauses == 0) {
+    // This landing pad contains only cleanup code.
+    CleanupHandler *Action = new CleanupHandler(BB);
+    CleanupHandlerMap[BB] = Action;
+    Actions.insertCleanupHandler(Action);
+    DEBUG(dbgs() << "  Assuming cleanup code in block " << BB->getName()
+                 << "\n");
+    assert(LPad->isCleanup());
+    return;
+  }
+
+  VisitedBlockSet VisitedBlocks;
+
+  while (HandlersFound != NumClauses) {
+    Constant *Selector = nullptr;
+    BasicBlock *NextBB = nullptr;
+
+    // See if the clause we're looking for is a catch-all.
+    // If so, the catch begins immediately.
+    if (isa<ConstantPointerNull>(LPad->getClause(HandlersFound))) {
+      // The catch all must occur last.
+      assert(HandlersFound == NumClauses - 1);
+
+      // See if there is any interesting code executed before the catch.
+      if (auto *CleanupAction = findCleanupHandler(BB, BB)) {
+        //   Add a cleanup entry to the list
+        Actions.insertCleanupHandler(CleanupAction);
+        DEBUG(dbgs() << "  Found cleanup code in block "
+                     << CleanupAction->getStartBlock()->getName() << "\n");
+      }
+
+      // Add the catch handler to the action list.
+      CatchHandler *Action =
+          new CatchHandler(BB, LPad->getClause(HandlersFound), nullptr);
+      CatchHandlerMap[BB] = Action;
+      Actions.insertCatchHandler(Action);
+      DEBUG(dbgs() << "  Catch all handler at block " << BB->getName() << "\n");
+      ++HandlersFound;
+      continue;
+    }
+
+    CatchHandler *CatchAction = findCatchHandler(BB, NextBB, VisitedBlocks);
+    // See if there is any interesting code executed before the dispatch.
+    if (auto *CleanupAction =
+            findCleanupHandler(BB, CatchAction->getStartBlock())) {
+      //   Add a cleanup entry to the list
+      Actions.insertCleanupHandler(CleanupAction);
+      DEBUG(dbgs() << "  Found cleanup code in block "
+                   << CleanupAction->getStartBlock()->getName() << "\n");
+    }
+
+    assert(CatchAction);
+    ++HandlersFound;
+
+    // Add the catch handler to the action list.
+    Actions.insertCatchHandler(CatchAction);
+    DEBUG(dbgs() << "  Found catch dispatch in block "
+                 << CatchAction->getStartBlock()->getName() << "\n");
+
+    // Move on to the block after the catch handler.
+    BB = NextBB;
+  }
+
+  // See if there is any interesting code executed before the resume.
+  if (auto *CleanupAction = findCleanupHandler(BB, BB)) {
+    //   Add a cleanup entry to the list
+    Actions.insertCleanupHandler(CleanupAction);
+    DEBUG(dbgs() << "  Found cleanup code in block "
+                 << CleanupAction->getStartBlock()->getName() << "\n");
+  }
+
+  // It's possible that some optimization moved code into a landingpad that
+  // wasn't
+  // previously being used for cleanup.  If that happens, we need to execute
+  // that
+  // extra code from a cleanup handler.
+  if (Actions.includesCleanup() && !LPad->isCleanup())
+    LPad->setCleanup(true);
+}
+
+// This function searches starting with the input block for the next
+// block that terminates with a branch whose condition is based on a selector
+// comparison.  This may be the input block.  See the mapLandingPadBlocks
+// comments for a discussion of control flow assumptions.
+//
+CatchHandler *WinEHPrepare::findCatchHandler(BasicBlock *BB,
+                                             BasicBlock *&NextBB,
+                                             VisitedBlockSet &VisitedBlocks) {
+  // See if we've already found a catch handler use it.
+  // Call count() first to avoid creating a null entry for blocks
+  // we haven't seen before.
+  if (CatchHandlerMap.count(BB) && CatchHandlerMap[BB] != nullptr) {
+    CatchHandler *Action = cast<CatchHandler>(CatchHandlerMap[BB]);
+    NextBB = Action->getNextBB();
+    return Action;
+  }
+
+  // VisitedBlocks applies only to the current search.  We still
+  // need to consider blocks that we've visited while mapping other
+  // landing pads.
+  VisitedBlocks.insert(BB);
+
+  BasicBlock *CatchBlock = nullptr;
+  Constant *Selector = nullptr;
+
+  // If this is the first time we've visited this block from any landing pad
+  // look to see if it is a selector dispatch block.
+  if (!CatchHandlerMap.count(BB)) {
+    if (isSelectorDispatch(BB, CatchBlock, Selector, NextBB)) {
+      CatchHandler *Action = new CatchHandler(BB, Selector, NextBB);
+      CatchHandlerMap[BB] = Action;
+      return Action;
+    }
+  }
+
+  // Visit each successor, looking for the dispatch.
+  // FIXME: We expect to find the dispatch quickly, so this will probably
+  //        work better as a breadth first search.
+  for (BasicBlock *Succ : successors(BB)) {
+    if (VisitedBlocks.count(Succ))
+      continue;
+
+    CatchHandler *Action = findCatchHandler(Succ, NextBB, VisitedBlocks);
+    if (Action)
+      return Action;
+  }
+  return nullptr;
+}
+
+// These are helper functions to combine repeated code from findCleanupHandler.
+static CleanupHandler *createCleanupHandler(CleanupHandlerMapTy &CleanupHandlerMap,
+                                            BasicBlock *BB) {
+  CleanupHandler *Action = new CleanupHandler(BB);
+  CleanupHandlerMap[BB] = Action;
+  return Action;
+}
+
+// This function searches starting with the input block for the next block that
+// contains code that is not part of a catch handler and would not be eliminated
+// during handler outlining.
+//
+CleanupHandler *WinEHPrepare::findCleanupHandler(BasicBlock *StartBB,
+                                                 BasicBlock *EndBB) {
+  // Here we will skip over the following:
+  //
+  // landing pad prolog:
+  //
+  // Unconditional branches
+  //
+  // Selector dispatch
+  //
+  // Resume pattern
+  //
+  // Anything else marks the start of an interesting block
+
+  BasicBlock *BB = StartBB;
+  // Anything other than an unconditional branch will kick us out of this loop
+  // one way or another.
+  while (BB) {
+    // If we've already scanned this block, don't scan it again.  If it is
+    // a cleanup block, there will be an action in the CleanupHandlerMap.
+    // If we've scanned it and it is not a cleanup block, there will be a
+    // nullptr in the CleanupHandlerMap.  If we have not scanned it, there will
+    // be no entry in the CleanupHandlerMap.  We must call count() first to
+    // avoid creating a null entry for blocks we haven't scanned.
+    if (CleanupHandlerMap.count(BB)) {
+      if (auto *Action = CleanupHandlerMap[BB]) {
+        return cast<CleanupHandler>(Action);
+      } else {
+        // Here we handle the case where the cleanup handler map contains a
+        // value for this block but the value is a nullptr.  This means that
+        // we have previously analyzed the block and determined that it did
+        // not contain any cleanup code.  Based on the earlier analysis, we
+        // know the the block must end in either an unconditional branch, a
+        // resume or a conditional branch that is predicated on a comparison
+        // with a selector.  Either the resume or the selector dispatch
+        // would terminate the search for cleanup code, so the unconditional
+        // branch is the only case for which we might need to continue
+        // searching.
+        if (BB == EndBB)
+          return nullptr;
+        BasicBlock *SuccBB;
+        if (!match(BB->getTerminator(), m_UnconditionalBr(SuccBB)))
+          return nullptr;
+        BB = SuccBB;
+        continue;
+      }
+    }
+
+    // Create an entry in the cleanup handler map for this block.  Initially
+    // we create an entry that says this isn't a cleanup block.  If we find
+    // cleanup code, the caller will replace this entry.
+    CleanupHandlerMap[BB] = nullptr;
+
+    TerminatorInst *Terminator = BB->getTerminator();
+
+    // Landing pad blocks have extra instructions we need to accept.
+    LandingPadMap *LPadMap = nullptr;
+    if (BB->isLandingPad()) {
+      LandingPadInst *LPad = BB->getLandingPadInst();
+      LPadMap = &LPadMaps[LPad];
+      if (!LPadMap->isInitialized())
+        LPadMap->mapLandingPad(LPad);
+    }
+
+    // Look for the bare resume pattern:
+    //   %exn2 = load i8** %exn.slot
+    //   %sel2 = load i32* %ehselector.slot
+    //   %lpad.val1 = insertvalue { i8*, i32 } undef, i8* %exn2, 0
+    //   %lpad.val2 = insertvalue { i8*, i32 } %lpad.val1, i32 %sel2, 1
+    //   resume { i8*, i32 } %lpad.val2
+    if (auto *Resume = dyn_cast<ResumeInst>(Terminator)) {
+      InsertValueInst *Insert1 = nullptr;
+      InsertValueInst *Insert2 = nullptr;
+      if (!isa<PHINode>(Resume->getOperand(0))) {
+        Insert2 = dyn_cast<InsertValueInst>(Resume->getOperand(0));
+        if (!Insert2)
+          return createCleanupHandler(CleanupHandlerMap, BB);
+        Insert1 = dyn_cast<InsertValueInst>(Insert2->getAggregateOperand());
+        if (!Insert1)
+          return createCleanupHandler(CleanupHandlerMap, BB);
+      }
+      for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(), IE = BB->end();
+           II != IE; ++II) {
+        Instruction *Inst = II;
+        if (LPadMap && LPadMap->isLandingPadSpecificInst(Inst))
+          continue;
+        if (Inst == Insert1 || Inst == Insert2 || Inst == Resume)
+          continue;
+        if (!Inst->hasOneUse() ||
+            (Inst->user_back() != Insert1 && Inst->user_back() != Insert2)) {
+          return createCleanupHandler(CleanupHandlerMap, BB);
+        }
+      }
+      return nullptr;
+    }
+
+    BranchInst *Branch = dyn_cast<BranchInst>(Terminator);
+    if (Branch) {
+      if (Branch->isConditional()) {
+        // Look for the selector dispatch.
+        //   %sel = load i32* %ehselector.slot
+        //   %2 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIf to i8*))
+        //   %matches = icmp eq i32 %sel12, %2
+        //   br i1 %matches, label %catch14, label %eh.resume
+        CmpInst *Compare = dyn_cast<CmpInst>(Branch->getCondition());
+        if (!Compare || !Compare->isEquality())
+          return createCleanupHandler(CleanupHandlerMap, BB);
+        for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(),
+                                  IE = BB->end();
+             II != IE; ++II) {
+          Instruction *Inst = II;
+          if (LPadMap && LPadMap->isLandingPadSpecificInst(Inst))
+            continue;
+          if (Inst == Compare || Inst == Branch)
+            continue;
+          if (!Inst->hasOneUse() || (Inst->user_back() != Compare))
+            return createCleanupHandler(CleanupHandlerMap, BB);
+          if (match(Inst, m_Intrinsic<Intrinsic::eh_typeid_for>()))
+            continue;
+          if (!isa<LoadInst>(Inst))
+            return createCleanupHandler(CleanupHandlerMap, BB);
+        }
+        // The selector dispatch block should always terminate our search.
+        assert(BB == EndBB);
+        return nullptr;
+      } else {
+        // Look for empty blocks with unconditional branches.
+        for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(),
+                                  IE = BB->end();
+             II != IE; ++II) {
+          Instruction *Inst = II;
+          if (LPadMap && LPadMap->isLandingPadSpecificInst(Inst))
+            continue;
+          if (Inst == Branch)
+            continue;
+          if (match(Inst, m_Intrinsic<Intrinsic::eh_endcatch>()))
+            continue;
+          // Anything else makes this interesting cleanup code.
+          return createCleanupHandler(CleanupHandlerMap, BB);
+        }
+        if (BB == EndBB)
+          return nullptr;
+        // The branch was unconditional.
+        BB = Branch->getSuccessor(0);
+        continue;
+      } // End else of if branch was conditional
+    }   // End if Branch
+
+    // Anything else makes this interesting cleanup code.
+    return createCleanupHandler(CleanupHandlerMap, BB);
+  }
+  return nullptr;
+}

lib/Transforms/Utils/CloneFunction.cpp

if (Director) {
     CloningDirector::CloningAction Action 
                            = Director->handleInstruction(VMap, OldTI, NewBB);
     // If the cloning director says stop, we want to stop everything, not
     // just break out of the loop (which would cause the terminator to be
     // cloned).  The cloning director is responsible for inserting a proper
     // terminator into the new basic block in this case.
     if (Action == CloningDirector::StopCloningBB)
       return;
+    if (Action == CloningDirector::CloneSuccessors) {
+      // If the director says to skip with a terminate instruction, we still
+      // need to clone this block's successors.
+      const TerminatorInst *TI = BB->getTerminator();
+      for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
+        ToClone.push_back(TI->getSuccessor(i));
+      return;
+    }
     assert(Action != CloningDirector::SkipInstruction && 
            "SkipInstruction is not valid for terminators.");
   }
   if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) {
     if (BI->isConditional()) {
       // If the condition was a known constant in the callee...
       ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
       // Or is a known constant in the caller...

test/CodeGen/WinEH/cppeh-catch-all.ll

 ;
 ; Parts of the IR have been hand-edited to simplify the test case.
 ; The full IR will be restored when Windows C++ EH support is complete.
 
 ; ModuleID = 'catch-all.cpp'
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
+; The function entry in this case remains unchanged.
+; CHECK: define void @_Z4testv() #0 {
+; CHECK: entry:
+; CHECK:   invoke void @_Z9may_throwv()
+; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]+]]
+
 ; Function Attrs: uwtable
 define void @_Z4testv() #0 {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
+; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           catch i8* null
+; CHECK-NOT:   extractvalue { i8*, i32 }
+; CHECK-NOT:   store i8*
+; CHECK-NOT:   store i32
+; CHECK-NOT:   br label %catch
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD_VAL]], i32 0, i8* null, i8* null, i8* bitcast (i8* (i8*, i8*)* @_Z4testv.catch to i8*))
+; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont]
+
 lpad:                                             ; preds = %entry
   %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           catch i8* null
   %tmp1 = extractvalue { i8*, i32 } %tmp, 0
   store i8* %tmp1, i8** %exn.slot
   %tmp2 = extractvalue { i8*, i32 } %tmp, 1
   store i32 %tmp2, i32* %ehselector.slot
   br label %catch
 
+; CHECK-NOT: catch:
+
 catch:                                            ; preds = %lpad
   %exn = load i8*, i8** %exn.slot
   call void @llvm.eh.begincatch(i8* %exn, i8* null) #2
   call void @_Z16handle_exceptionv()
   br label %invoke.cont2
 
+; CHECK-NOT: invoke.cont2:
+
 invoke.cont2:                                     ; preds = %catch
   call void @llvm.eh.endcatch()
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %invoke.cont
   ret void
+
+; CHECK: }
 }
 
 ; CHECK: define internal i8* @_Z4testv.catch(i8*, i8*) {
 ; CHECK: entry:
 ; CHECK:   call void @_Z16handle_exceptionv()
 ; CHECK:   ret i8* blockaddress(@_Z4testv, %try.cont)
 ; CHECK: }
 

test/CodeGen/WinEH/cppeh-catch-scalar.ll

 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 @_ZTIi = external constant i8*
 
 ; The function entry will be rewritten like this.
 ; CHECK: define void @_Z4testv() #0 {
 ; CHECK: entry:
-; CHECK:   %exn.slot = alloca i8*
-; CHECK:   %ehselector.slot = alloca i32
-; CHECK:   %i = alloca i32, align 4
-; CHECK:   call void (...)* @llvm.frameescape(i32* %i)
+; CHECK:   [[I_PTR:\%.+]] = alloca i32, align 4
+; CHECK:   call void (...)* @llvm.frameescape(i32* [[I_PTR]])
 ; CHECK:   invoke void @_Z9may_throwv()
-; CHECK:           to label %invoke.cont unwind label %lpad
+; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]+]]
 
 ; Function Attrs: uwtable
 define void @_Z4testv() #0 {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %i = alloca i32, align 4
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
+; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           catch i8* bitcast (i8** @_ZTIi to i8*)
+; CHECK-NOT:   extractvalue { i8*, i32 }
+; CHECK-NOT:   store i8*
+; CHECK-NOT:   store i32
+; CHECK-NOT:   br label
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD_VAL]], i32 0, i8* bitcast (i8** @_ZTIi to i8*), i32* %i, i8* bitcast (i8* (i8*, i8*)* @_Z4testv.catch to i8*))
+; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont]
+
 lpad:                                             ; preds = %entry
   %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %tmp1 = extractvalue { i8*, i32 } %tmp, 0
   store i8* %tmp1, i8** %exn.slot
   %tmp2 = extractvalue { i8*, i32 } %tmp, 1
   store i32 %tmp2, i32* %ehselector.slot
   br label %catch.dispatch
 
+; CHECK-NOT: catch-dispatch:
+
 catch.dispatch:                                   ; preds = %lpad
   %sel = load i32, i32* %ehselector.slot
   %tmp3 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) #3
   %matches = icmp eq i32 %sel, %tmp3
   br i1 %matches, label %catch, label %eh.resume
 
+; CHECK-NOT: catch:
+
 catch:                                            ; preds = %catch.dispatch
   %exn11 = load i8*, i8** %exn.slot
   %i.i8 = bitcast i32* %i to i8*
   call void @llvm.eh.begincatch(i8* %exn11, i8* %i.i8) #3
   %tmp7 = load i32, i32* %i, align 4
   call void @_Z10handle_inti(i32 %tmp7)
   br label %invoke.cont2
 
+; CHECK-NOT: invoke.cont2:
+
 invoke.cont2:                                     ; preds = %catch
   call void @llvm.eh.endcatch() #3
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %invoke.cont
   ret void
 
+; CHECK-NOT: eh.resume:
+
 eh.resume:                                        ; preds = %catch.dispatch
   %exn3 = load i8*, i8** %exn.slot
   %sel4 = load i32, i32* %ehselector.slot
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn3, 0
   %lpad.val5 = insertvalue { i8*, i32 } %lpad.val, i32 %sel4, 1
   resume { i8*, i32 } %lpad.val5
+
+; CHECK: }
 }
 
 ; CHECK: define internal i8* @_Z4testv.catch(i8*, i8*) {
 ; CHECK: entry:
-; CHECK:   %i.i81 = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 0)
-; CHECK:   %i = bitcast i8* %i.i81 to i32*
-; CHECK:   %tmp7 = load i32, i32* %i, align 4
-; CHECK:   call void @_Z10handle_inti(i32 %tmp7)
+; CHECK:   [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 0)
+; CHECK:   [[I_PTR1:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
+; CHECK:   [[TMP:\%.+]] = load i32, i32* [[I_PTR1]], align 4
+; CHECK:   call void @_Z10handle_inti(i32 [[TMP]])
 ; CHECK:   ret i8* blockaddress(@_Z4testv, %try.cont)
 ; CHECK: }
 
 declare void @_Z9may_throwv() #1
 
 declare i32 @__CxxFrameHandler3(...)
 
 ; Function Attrs: nounwind readnone

test/CodeGen/WinEH/cppeh-frame-vars.ll

 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 
 ; The function entry should be rewritten like this.
 ; CHECK: define void @"\01?test@@YAXXZ"() #0 {
 ; CHECK: entry:
-; CHECK:   %NumExceptions = alloca i32, align 4
-; CHECK:   %ExceptionVal = alloca [10 x i32], align 16
-; CHECK:   %Data = alloca %struct.SomeData, align 4
-; CHECK:   %i = alloca i32, align 4
-; CHECK:   %exn.slot = alloca i8*
-; CHECK:   %ehselector.slot = alloca i32
-; CHECK:   %e = alloca i32, align 4
-; CHECK:   store i32 0, i32* %NumExceptions, align 4
-; CHECK:   %tmp = bitcast %struct.SomeData* %Data to i8*
-; CHECK:   call void @llvm.memset(i8* %tmp, i8 0, i64 8, i32 4, i1 false)
-; CHECK:   store i32 0, i32* %i, align 4
-; CHECK:   call void (...)* @llvm.frameescape(i32* %e, i32* %NumExceptions, [10 x i32]* %ExceptionVal, i32* %i, %struct.SomeData* %Data)
+; CHECK:   [[NUMEXCEPTIONS_PTR:\%.+]] = alloca i32, align 4
+; CHECK:   [[EXCEPTIONVAL_PTR:\%.+]] = alloca [10 x i32], align 16
+; CHECK:   [[DATA_PTR:\%.+]] = alloca %struct.SomeData, align 4
+; CHECK:   [[I_PTR:\%.+]] = alloca i32, align 4
+; CHECK:   [[E_PTR:\%.+]] = alloca i32, align 4
+; CHECK:   store i32 0, i32* [[NUMEXCEPTIONS_PTR]], align 4
+; CHECK:   [[TMP:\%.+]] = bitcast %struct.SomeData* [[DATA_PTR]] to i8*
+; CHECK:   call void @llvm.memset(i8* [[TMP]], i8 0, i64 8, i32 4, i1 false)
+; CHECK:   store i32 0, i32* [[I_PTR]], align 4
+; CHECK:   call void (...)* @llvm.frameescape(i32* [[E_PTR]], i32* [[NUMEXCEPTIONS_PTR]], [10 x i32]* [[EXCEPTIONVAL_PTR]], i32* [[I_PTR]], %struct.SomeData* [[DATA_PTR]])
 ; CHECK:   br label %for.cond
 
 ; Function Attrs: uwtable
 define void @"\01?test@@YAXXZ"() #0 {
 entry:
   %NumExceptions = alloca i32, align 4
   %ExceptionVal = alloca [10 x i32], align 16
   %Data = alloca %struct.SomeData, align 4
   %i = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %e = alloca i32, align 4
   store i32 0, i32* %NumExceptions, align 4
   %tmp = bitcast %struct.SomeData* %Data to i8*
   call void @llvm.memset(i8* %tmp, i8 0, i64 8, i32 4, i1 false)
   store i32 0, i32* %i, align 4
   br label %for.cond
 
 for.cond:                                         ; preds = %for.inc, %entry
   %tmp1 = load i32, i32* %i, align 4
   %cmp = icmp slt i32 %tmp1, 10
   br i1 %cmp, label %for.body, label %for.end
 
+; CHECK: for.body:
+; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
+; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]+]]
+
 for.body:                                         ; preds = %for.cond
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %for.body
   %tmp2 = load i32, i32* %i, align 4
   %a = getelementptr inbounds %struct.SomeData, %struct.SomeData* %Data, i32 0, i32 0
   %tmp3 = load i32, i32* %a, align 4
   %add = add nsw i32 %tmp3, %tmp2
   store i32 %add, i32* %a, align 4
   br label %try.cont
 
+; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %for.body
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
+; CHECK-NOT:   extractvalue { i8*, i32 }
+; CHECK-NOT:   store i8*
+; CHECK-NOT:   store i32
+; CHECK-NOT:   br label
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD_VAL]], i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* %e, i8* bitcast (i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch" to i8*))
+; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont]
+
 lpad:                                             ; preds = %for.body
   %tmp4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %tmp5 = extractvalue { i8*, i32 } %tmp4, 0
   store i8* %tmp5, i8** %exn.slot
   %tmp6 = extractvalue { i8*, i32 } %tmp4, 1
   store i32 %tmp6, i32* %ehselector.slot
   br label %catch.dispatch
 
+; CHECK-NOT: catch.dispatch:
+
 catch.dispatch:                                   ; preds = %lpad
   %sel = load i32, i32* %ehselector.slot
   %tmp7 = call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)) #1
   %matches = icmp eq i32 %sel, %tmp7
   br i1 %matches, label %catch, label %eh.resume
 
+; CHECK-NOT: catch:
+
 catch:                                            ; preds = %catch.dispatch
   %exn = load i8*, i8** %exn.slot
   %e.i8 = bitcast i32* %e to i8*
   call void @llvm.eh.begincatch(i8* %exn, i8* %e.i8) #1
   %tmp11 = load i32, i32* %e, align 4
   %tmp12 = load i32, i32* %NumExceptions, align 4
   %idxprom = sext i32 %tmp12 to i64
   %arrayidx = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i32 0, i64 %idxprom
   store i32 %tmp11, i32* %arrayidx, align 4
   %tmp13 = load i32, i32* %NumExceptions, align 4
   %inc = add nsw i32 %tmp13, 1
   store i32 %inc, i32* %NumExceptions, align 4
   %tmp14 = load i32, i32* %e, align 4
   %tmp15 = load i32, i32* %i, align 4
   %cmp1 = icmp eq i32 %tmp14, %tmp15
   br i1 %cmp1, label %if.then, label %if.else
 
+; CHECK-NOT: if.then:
+
 if.then:                                          ; preds = %catch
   %tmp16 = load i32, i32* %e, align 4
   %b = getelementptr inbounds %struct.SomeData, %struct.SomeData* %Data, i32 0, i32 1
   %tmp17 = load i32, i32* %b, align 4
   %add2 = add nsw i32 %tmp17, %tmp16
   store i32 %add2, i32* %b, align 4
   br label %if.end
 
+; CHECK-NOT: if.else:
+
 if.else:                                          ; preds = %catch
   %tmp18 = load i32, i32* %e, align 4
   %a3 = getelementptr inbounds %struct.SomeData, %struct.SomeData* %Data, i32 0, i32 0
   %tmp19 = load i32, i32* %a3, align 4
   %add4 = add nsw i32 %tmp19, %tmp18
   store i32 %add4, i32* %a3, align 4
   br label %if.end
 
+; CHECK-NOT: if.end:
+
 if.end:                                           ; preds = %if.else, %if.then
   call void @llvm.eh.endcatch() #1
   br label %try.cont
 
 try.cont:                                         ; preds = %if.end, %invoke.cont
   %tmp20 = load i32, i32* %NumExceptions, align 4
   call void @"\01?does_not_throw@@YAXH@Z"(i32 %tmp20)
   br label %for.inc
 
 for.inc:                                          ; preds = %try.cont
   %tmp21 = load i32, i32* %i, align 4
   %inc5 = add nsw i32 %tmp21, 1
   store i32 %inc5, i32* %i, align 4
   br label %for.cond
 
 for.end:                                          ; preds = %for.cond
   %tmp22 = load i32, i32* %NumExceptions, align 4
   %arraydecay = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i32 0, i32 0
   call void @"\01?dump@@YAXPEAHHAEAUSomeData@@@Z"(i32* %arraydecay, i32 %tmp22, %struct.SomeData* dereferenceable(8) %Data)
   ret void
 
+; CHECK-NOT: eh.resume:
+
 eh.resume:                                        ; preds = %catch.dispatch
   %exn6 = load i8*, i8** %exn.slot
   %sel7 = load i32, i32* %ehselector.slot
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn6, 0
   %lpad.val8 = insertvalue { i8*, i32 } %lpad.val, i32 %sel7, 1
   resume { i8*, i32 } %lpad.val8
+
+; CHECK: }
 }
 
 ; The following catch handler should be outlined.
 ; CHECK-LABEL: define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*) {
 ; CHECK: entry:
-; CHECK:   %e.i81 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
-; CHECK:   %e = bitcast i8* %e.i81 to i32*
-; CHECK:   %NumExceptions.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
-; CHECK:   %NumExceptions = bitcast i8* %NumExceptions.i8 to i32*
-; CHECK:   %ExceptionVal.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
-; CHECK:   %ExceptionVal = bitcast i8* %ExceptionVal.i8 to [10 x i32]*
-; CHECK:   %i.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 3)
-; CHECK:   %i = bitcast i8* %i.i8 to i32*
-; CHECK:   %Data.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 4)
-; CHECK:   %Data = bitcast i8* %Data.i8 to %struct.SomeData*
-; CHECK:   %tmp11 = load i32, i32* %e, align 4
-; CHECK:   %tmp12 = load i32, i32* %NumExceptions, align 4
-; CHECK:   %idxprom = sext i32 %tmp12 to i64
-; CHECK:   %arrayidx = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i32 0, i64 %idxprom
-; CHECK:   store i32 %tmp11, i32* %arrayidx, align 4
-; CHECK:   %tmp13 = load i32, i32* %NumExceptions, align 4
-; CHECK:   %inc = add nsw i32 %tmp13, 1
-; CHECK:   store i32 %inc, i32* %NumExceptions, align 4
-; CHECK:   %tmp14 = load i32, i32* %e, align 4
-; CHECK:   %tmp15 = load i32, i32* %i, align 4
-; CHECK:   %cmp1 = icmp eq i32 %tmp14, %tmp15
-; CHECK:   br i1 %cmp1, label %if.then, label %if.else
+; CHECK:   [[RECOVER_E:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
+; CHECK:   [[E_PTR1:\%.+]] = bitcast i8* [[RECOVER_E]] to i32*
+; CHECK:   [[RECOVER_NUMEXCEPTIONS:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
+; CHECK:   [[NUMEXCEPTIONS_PTR1:\%.+]] = bitcast i8* [[RECOVER_NUMEXCEPTIONS]] to i32*
+; CHECK:   [[RECOVER_EXCEPTIONVAL:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
+; CHECK:   [[EXCEPTIONVAL_PTR1:\%.+]] = bitcast i8* [[RECOVER_EXCEPTIONVAL]] to [10 x i32]*
+; CHECK:   [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 3)
+; CHECK:   [[I_PTR1:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
+; CHECK:   [[RECOVER_DATA:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 4)
+; CHECK:   [[DATA_PTR1:\%.+]] = bitcast i8* [[RECOVER_DATA]] to %struct.SomeData*
+; CHECK:   [[TMP:\%.+]] = load i32, i32* [[E_PTR1]], align 4
+; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[NUMEXCEPTIONS_PTR]], align 4
+; CHECK:   [[IDXPROM:\%.+]] = sext i32 [[TMP1]] to i64
+; CHECK:   [[ARRAYIDX:\%.+]] = getelementptr inbounds [10 x i32], [10 x i32]* [[EXCEPTIONVAL_PTR1]], i32 0, i64 [[IDXPROM]]
+; CHECK:   store i32 [[TMP]], i32* [[ARRAYIDX]], align 4
+; CHECK:   [[TMP2:\%.+]] = load i32, i32* [[NUMEXCEPTIONS_PTR1]], align 4
+; CHECK:   [[INC:\%.+]] = add nsw i32 [[TMP2]], 1
+; CHECK:   store i32 [[INC]], i32* [[NUMEXCEPTIONS_PTR]], align 4
+; CHECK:   [[TMP3:\%.+]] = load i32, i32* [[E_PTR1]], align 4
+; CHECK:   [[TMP4:\%.+]] = load i32, i32* [[I_PTR1]], align 4
+; CHECK:   [[CMP:\%.+]] = icmp eq i32 [[TMP3]], [[TMP4]]
+; CHECK:   br i1 [[CMP]], label %if.then, label %if.else
 ;
 ; CHECK: if.then:                                          ; preds = %entry
-; CHECK:   %tmp16 = load i32, i32* %e, align 4
-; CHECK:   %b = getelementptr inbounds %struct.SomeData, %struct.SomeData* %Data, i32 0, i32 1
-; CHECK:   %tmp17 = load i32, i32* %b, align 4
-; CHECK:   %add2 = add nsw i32 %tmp17, %tmp16
-; CHECK:   store i32 %add2, i32* %b, align 4
+; CHECK:   [[TMP5:\%.+]] = load i32, i32* [[E_PTR1]], align 4
+; CHECK:   [[B_PTR:\%.+]] = getelementptr inbounds %struct.SomeData, %struct.SomeData* [[DATA_PTR1]], i32 0, i32 1
+; CHECK:   [[TMP6:\%.+]] = load i32, i32* [[B_PTR]], align 4
+; CHECK:   %add2 = add nsw i32 [[TMP6]], [[TMP5]]
+; CHECK:   store i32 [[ADD:\%.+]], i32* [[B_PTR]], align 4
 ; CHECK:   br label %if.end
 ;
 ; CHECK: if.else:                                          ; preds = %entry
-; CHECK:   %tmp18 = load i32, i32* %e, align 4
-; CHECK:   %a3 = getelementptr inbounds %struct.SomeData, %struct.SomeData* %Data, i32 0, i32 0
-; CHECK:   %tmp19 = load i32, i32* %a3, align 4
-; CHECK:   %add4 = add nsw i32 %tmp19, %tmp18
-; CHECK:   store i32 %add4, i32* %a3, align 4
+; CHECK:   [[TMP7:\%.+]] = load i32, i32* %e, align 4
+; CHECK:   [[A3:\%.+]] = getelementptr inbounds %struct.SomeData, %struct.SomeData* %Data, i32 0, i32 0
+; CHECK:   [[TMP8:\%.+]] = load i32, i32* %a3, align 4
+; CHECK:   [[ADD1:\%.+]] = add nsw i32 [[TMP8]], [[TMP7]]
+; CHECK:   store i32 [[ADD1]], i32* [[A3]], align 4
 ; CHECK:   br label %if.end
 ;
 ; CHECK: if.end:                                           ; preds = %if.else, %if.then
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
 ; CHECK: }
 
 
-
-
-
-
 ; Function Attrs: nounwind
 declare void @llvm.memset(i8* nocapture, i8, i64, i32, i1) #1
 
 declare void @"\01?may_throw@@YAXXZ"() #2
 
 declare i32 @__CxxFrameHandler3(...)
 
 ; Function Attrs: nounwind readnone

test/CodeGen/WinEH/cppeh-inalloca.ll

 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 
 ; The function entry should be rewritten like this.
 ; CHECK: define i32 @"\01?test@@YAHUA@@@Z"(<{ %struct.A }>* inalloca) #0 {
 ; CHECK: entry:
-; CHECK:   %.tmp.reg2mem = alloca <{ %struct.A }>*
-; CHECK:   %.tmp = select i1 true, <{ %struct.A }>* %0, <{ %struct.A }>* undef
-; CHECK:   store <{ %struct.A }>* %.tmp, <{ %struct.A }>** %.tmp.reg2mem
-; CHECK:   %retval = alloca i32, align 4
-; CHECK:   %exn.slot = alloca i8*
-; CHECK:   %ehselector.slot = alloca i32
-; CHECK:   %e = alloca i32, align 4
-; CHECK:   %cleanup.dest.slot = alloca i32
-; CHECK:   call void (...)* @llvm.frameescape(i32* %e, <{ %struct.A }>** %.tmp.reg2mem, i32* %retval, i32* %cleanup.dest.slot)
+; CHECK:   [[TMP_REGMEM:\%.+]] = alloca <{ %struct.A }>*
+; CHECK:   [[TMP:\%.+]] = select i1 true, <{ %struct.A }>* %0, <{ %struct.A }>* undef
+; CHECK:   store <{ %struct.A }>* [[TMP]], <{ %struct.A }>** [[TMP_REGMEM]]
+; CHECK:   [[RETVAL:\%.+]] = alloca i32, align 4
+; CHECK:   [[E_PTR:\%.+]] = alloca i32, align 4
+; CHECK:   [[CLEANUP_SLOT:\%.+]] = alloca i32
+; CHECK:   call void (...)* @llvm.frameescape(i32* %e, <{ %struct.A }>** [[TMP_REGMEM]], i32* [[RETVAL]], i32* [[CLEANUP_SLOT]])
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
-; CHECK:           to label %invoke.cont unwind label %lpad
+; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 define i32 @"\01?test@@YAHUA@@@Z"(<{ %struct.A }>* inalloca) #0 {
 entry:
   %retval = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %e = alloca i32, align 4
   %cleanup.dest.slot = alloca i32
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
+; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           cleanup
+; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
+; CHECK-NOT:   extractvalue { i8*, i32 }
+; CHECK-NOT:   store i8*
+; CHECK-NOT:   store i32
+; CHECK-NOT:   br label %catch.dispatch
+; CHECK:   [[RECOVER:\%recover.*]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD_VAL]], i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* %e, i8* bitcast (i8* (i8*, i8*)* @"\01?test@@YAHUA@@@Z.catch" to i8*), i32 1, i8* bitcast (void (i8*, i8*)* @"\01?test@@YAHUA@@@Z.cleanup" to i8*))
+; CHECK:   indirectbr i8* [[RECOVER]], [label %cleanup]
+
 lpad:                                             ; preds = %entry
   %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           cleanup
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   br label %catch.dispatch
 
+; CHECK-NOT: catch.dispatch:
+
 catch.dispatch:                                   ; preds = %lpad
   %sel = load i32, i32* %ehselector.slot
   %4 = call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)) #3
   %matches = icmp eq i32 %sel, %4
   br i1 %matches, label %catch, label %ehcleanup
 
+; CHECK-NOT: catch:
+
 catch:                                            ; preds = %catch.dispatch
   %exn = load i8*, i8** %exn.slot
   %e.i8 = bitcast i32* %e to i8*
   call void @llvm.eh.begincatch(i8* %exn, i8* %e.i8) #3
   %a = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* %0, i32 0, i32 0
   %a1 = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 0
   %tmp8 = load i32, i32* %a1, align 4
   %tmp9 = load i32, i32* %e, align 4
   %add = add nsw i32 %tmp8, %tmp9
   store i32 %add, i32* %retval
   store i32 1, i32* %cleanup.dest.slot
   call void @llvm.eh.endcatch() #3
   br label %cleanup
 
 try.cont:                                         ; preds = %invoke.cont
   store i32 0, i32* %retval
   store i32 1, i32* %cleanup.dest.slot
   br label %cleanup
 
 ; The cleanup block should be re-written like this.
-; CHECK: cleanup:                                          ; preds = %try.cont, %catch
+; CHECK: cleanup:{{[ ]+}}; preds = %[[LPAD_LABEL]], %try.cont
 ; CHECK-NOT:  %a2 = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* %0, i32 0, i32 0
-; CHECK:   %.tmp.reload1 = load volatile <{ %struct.A }>*, <{ %struct.A }>** %.tmp.reg2mem
-; CHECK:   %a2 = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* %.tmp.reload1, i32 0, i32 0
-; CHECK:   call x86_thiscallcc void @"\01??1A@@QAE@XZ"(%struct.A* %a2) #2
-; CHECK:   %tmp10 = load i32, i32* %retval
-; CHECK:   ret i32 %tmp10
+; CHECK:   [[TMP_RELOAD:\%.+]] = load volatile <{ %struct.A }>*, <{ %struct.A }>** [[TMP_REGMEM]]
+; CHECK:   [[A2:\%.+]] = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* [[TMP_RELOAD]], i32 0, i32 0
+; CHECK:   call x86_thiscallcc void @"\01??1A@@QAE@XZ"(%struct.A* [[A2]])
+; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[RETVAL]]
+; CHECK:   ret i32 [[TMP1]]
 
 cleanup:                                          ; preds = %try.cont, %catch
   %a2 = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* %0, i32 0, i32 0
   call x86_thiscallcc void @"\01??1A@@QAE@XZ"(%struct.A* %a2) #3
   %tmp10 = load i32, i32* %retval
   ret i32 %tmp10
 
+; CHECK-NOT: ehcleanup:
+
 ehcleanup:                                        ; preds = %catch.dispatch
   %a3 = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* %0, i32 0, i32 0
   call x86_thiscallcc void @"\01??1A@@QAE@XZ"(%struct.A* %a3) #3
   br label %eh.resume
 
+; CHECK-NOT: eh.resume:
+
 eh.resume:                                        ; preds = %ehcleanup
   %exn2 = load i8*, i8** %exn.slot
   %sel3 = load i32, i32* %ehselector.slot
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn2, 0
   %lpad.val4 = insertvalue { i8*, i32 } %lpad.val, i32 %sel3, 1
   resume { i8*, i32 } %lpad.val4
+
+; CHECK: }
 }
 
 ; The following catch handler should be outlined.
 ; CHECK: define internal i8* @"\01?test@@YAHUA@@@Z.catch"(i8*, i8*) {
 ; CHECK: entry:
-; CHECK:   %e.i81 = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 0)
-; CHECK:   %e = bitcast i8* %e.i81 to i32*
-; CHECK:   %eh.temp.alloca.i8 = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 1)
-; CHECK:   %eh.temp.alloca = bitcast i8* %eh.temp.alloca.i8 to <{ %struct.A }>**
-; CHECK:   %.reload = load <{ %struct.A }>*, <{ %struct.A }>** %eh.temp.alloca
-; CHECK:   %retval.i8 = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 2)
-; CHECK:   %retval = bitcast i8* %retval.i8 to i32*
-; CHECK:   %cleanup.dest.slot.i8 = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 3)
-; CHECK:   %cleanup.dest.slot = bitcast i8* %cleanup.dest.slot.i8 to i32*
-; CHECK:   %e.i8 = bitcast i32* %e to i8*
-; CHECK:   %a = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* %.reload, i32 0, i32 0
-; CHECK:   %a1 = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 0
-; CHECK:   %tmp8 = load i32, i32* %a1, align 4
-; CHECK:   %tmp9 = load i32, i32* %e, align 4
-; CHECK:   %add = add nsw i32 %tmp8, %tmp9
-; CHECK:   store i32 %add, i32* %retval
-; CHECK:   store i32 1, i32* %cleanup.dest.slot
+; CHECK:   [[RECOVER_E:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 0)
+; CHECK:   [[E_PTR:\%.+]] = bitcast i8* [[RECOVER_E]] to i32*
+; CHECK:   [[RECOVER_EH_TEMP:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 1)
+; CHECK:   [[EH_TEMP:\%.+]] = bitcast i8* [[RECOVER_EH_TEMP]] to <{ %struct.A }>**
+; CHECK:   [[TMP_RELOAD:\%.+]] = load <{ %struct.A }>*, <{ %struct.A }>** [[EH_TEMP]]
+; CHECK:   [[RECOVER_RETVAL:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 2)
+; CHECK:   [[RETVAL1:\%.+]] = bitcast i8* [[RECOVER_RETVAL]] to i32*
+; CHECK:   [[RECOVER_CLEANUPSLOT:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 3)
+; CHECK:   [[CLEANUPSLOT1:\%.+]] = bitcast i8* [[RECOVER_CLEANUPSLOT]] to i32*
+; CHECK:   [[E_I8PTR:\%.+]] = bitcast i32* [[E_PTR]] to i8*
+; CHECK:   [[RECOVER_A:\%.+]] = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* [[TMP_RELOAD]], i32 0, i32 0
+; CHECK:   [[A1:\%.+]] = getelementptr inbounds %struct.A, %struct.A* [[RECOVER_A]], i32 0, i32 0
+; CHECK:   [[TMP2:\%.+]] = load i32, i32* [[A1]], align 4
+; CHECK:   [[TMP3:\%.+]] = load i32, i32* [[E_PTR]], align 4
+; CHECK:   [[ADD:\%.+]] = add nsw i32 [[TMP2]], [[TMP3]]
+; CHECK:   store i32 [[ADD]], i32* [[RETVAL1]]
+; CHECK:   store i32 1, i32* [[CLEANUPSLOT1]]
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAHUA@@@Z", %cleanup)
 ; CHECK: }
 
+; The following cleanup handler should be outlined.
+; CHECK: define internal void @"\01?test@@YAHUA@@@Z.cleanup"(i8*, i8*) {
+; CHECK: entry:
+; CHECK:   [[RECOVER_EH_TEMP1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (i32 (<{ %struct.A }>*)* @"\01?test@@YAHUA@@@Z" to i8*), i8* %1, i32 1)
+; CHECK:   [[EH_TEMP1:\%.+]] = bitcast i8* [[RECOVER_EH_TEMP]] to <{ %struct.A }>**
+; CHECK:   [[TMP_RELOAD1:\%.+]] = load <{ %struct.A }>*, <{ %struct.A }>** [[EH_TEMP1]]
+; CHECK:   [[A3:\%.+]] = getelementptr inbounds <{ %struct.A }>, <{ %struct.A }>* [[TMP_RELOAD1]], i32 0, i32 0
+; CHECK:   call x86_thiscallcc void @"\01??1A@@QAE@XZ"(%struct.A* [[A3]])
+; CHECK:   ret void
+; CHECK: }
+
 declare void @"\01?may_throw@@YAXXZ"() #0
 
 declare i32 @__CxxFrameHandler3(...)
 
 ; Function Attrs: nounwind readnone
 declare i32 @llvm.eh.typeid.for(i8*) #1
 
 declare void @llvm.eh.begincatch(i8*, i8*)

test/CodeGen/WinEH/cppeh-min-unwind.ll

 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 %class.SomeClass = type { [28 x i32] }
 
 ; The function entry should be rewritten like this.
 ; CHECK: define void @_Z4testv() #0 {
 ; CHECK: entry:
-; CHECK:   %obj = alloca %class.SomeClass, align 4
-; CHECK:   call void @_ZN9SomeClassC1Ev(%class.SomeClass* %obj)
-; CHECK:   call void (...)* @llvm.frameescape(%class.SomeClass* %obj)
+; CHECK:   [[OBJ_PTR:\%.+]] = alloca %class.SomeClass, align 4
+; CHECK:   call void @_ZN9SomeClassC1Ev(%class.SomeClass* [[OBJ_PTR]])
+; CHECK:   call void (...)* @llvm.frameescape(%class.SomeClass* [[OBJ_PTR]])
 ; CHECK:   invoke void @_Z9may_throwv()
-; CHECK:           to label %invoke.cont unwind label %lpad
+; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]+]]
 
 ; Function Attrs: uwtable
 define void @_Z4testv() #0 {
 entry:
   %obj = alloca %class.SomeClass, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   call void @_ZN9SomeClassC1Ev(%class.SomeClass* %obj)
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   call void @_ZN9SomeClassD1Ev(%class.SomeClass* %obj)
   ret void
 
+; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           cleanup
+; CHECK-NOT:   extractvalue { i8*, i32 }
+; CHECK-NOT:   store i8*
+; CHECK-NOT:   store i32
+; CHECK-NOT:   call void @_ZN9SomeClassD1Ev
+; CHECK-NOT:   br label %eh.resume
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD_VAL]], i32 1, i8* bitcast (void (i8*, i8*)* @_Z4testv.cleanup to i8*))
+; CHECK:   indirectbr i8* [[RECOVER]], []
+
 lpad:                                             ; preds = %entry
   %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           cleanup
   %tmp1 = extractvalue { i8*, i32 } %tmp, 0
   store i8* %tmp1, i8** %exn.slot
   %tmp2 = extractvalue { i8*, i32 } %tmp, 1
   store i32 %tmp2, i32* %ehselector.slot
   call void @_ZN9SomeClassD1Ev(%class.SomeClass* %obj)
   br label %eh.resume
 
+; CHECK-NOT: eh.resume:
+
 eh.resume:                                        ; preds = %lpad
   %exn = load i8*, i8** %exn.slot
   %sel = load i32, i32* %ehselector.slot
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn, 0
   %lpad.val2 = insertvalue { i8*, i32 } %lpad.val, i32 %sel, 1
   resume { i8*, i32 } %lpad.val2
+
+; CHECK: }
 }
 
 ; This cleanup handler should be outlined.
 ; CHECK: define internal void @_Z4testv.cleanup(i8*, i8*) {
 ; CHECK: entry:
-; CHECK:   %obj.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 0)
-; CHECK:   %obj = bitcast i8* %obj.i8 to %class.SomeClass*
-; CHECK:   call void @_ZN9SomeClassD1Ev(%class.SomeClass* %obj)
+; CHECK:   [[RECOVER_OBJ:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 0)
+; CHECK:   [[OBJ_PTR1:\%.+]] = bitcast i8* [[RECOVER_OBJ]] to %class.SomeClass*
+; CHECK:   call void @_ZN9SomeClassD1Ev(%class.SomeClass* [[OBJ_PTR1]])
 ; CHECK:   ret void
 ; CHECK: }
 
 declare void @_ZN9SomeClassC1Ev(%class.SomeClass*) #1
 
 declare void @_Z9may_throwv() #1
 
 declare i32 @__CxxFrameHandler3(...)

test/CodeGen/WinEH/cppeh-nested-2.ll

+; RUN: opt -mtriple=x86_64-pc-windows-msvc -winehprepare -S -o - < %s | FileCheck %s
+
+; This test is based on the following code:
+;
+; class Inner {
+; public:
+;   Inner();
+;   ~Inner();
+; };
+; class Outer {
+; public:
+;   Outer();
+;   ~Outer();
+; };
+; void test() {
+;   try {
+;     Outer outer;
+;     try {
+;        Inner inner;
+;        may_throw();
+;     } catch (int i) {
+;       handle_int(i);
+;     }
+;   } catch (float f) {
+;     handle_float(f);
+;   }
+;   done();
+; }
+
+; ModuleID = 'nested-2.cpp'
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+%class.Outer = type { i8 }
+%class.Inner = type { i8 }
+
+@_ZTIf = external constant i8*
+@_ZTIi = external constant i8*
+
+; The function entry should be rewritten like this.
+; CHECK: define void @_Z4testv() #0 {
+; CHECK: entry:
+; CHECK:   %outer = alloca %class.Outer, align 1
+; CHECK:   %inner = alloca %class.Inner, align 1
+; CHECK:   %i = alloca i32, align 4
+; CHECK:   %f = alloca float, align 4
+; CHECK:   call void (...)* @llvm.frameescape(float* %f, i32* %i, %class.Outer* %outer, %class.Inner* %inner)
+; CHECK:   invoke void @_ZN5OuterC1Ev(%class.Outer* %outer)
+; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
+
+; Function Attrs: uwtable
+define void @_Z4testv() #0 {
+entry:
+  %outer = alloca %class.Outer, align 1
+  %exn.slot = alloca i8*
+  %ehselector.slot = alloca i32
+  %inner = alloca %class.Inner, align 1
+  %i = alloca i32, align 4
+  %f = alloca float, align 4
+  invoke void @_ZN5OuterC1Ev(%class.Outer* %outer)
+          to label %invoke.cont unwind label %lpad
+
+; CHECK: invoke.cont:
+; CHECK:   invoke void @_ZN5InnerC1Ev(%class.Inner* %inner)
+; CHECK:           to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]]
+
+invoke.cont:                                      ; preds = %entry
+  invoke void @_ZN5InnerC1Ev(%class.Inner* %inner)
+          to label %invoke.cont2 unwind label %lpad1
+
+; CHECK: invoke.cont2:
+; CHECK:   invoke void @_Z9may_throwv()
+; CHECK:           to label %invoke.cont4 unwind label %[[LPAD3_LABEL:lpad[0-9]*]]
+
+invoke.cont2:                                     ; preds = %invoke.cont
+  invoke void @_Z9may_throwv()
+          to label %invoke.cont4 unwind label %lpad3
+
+; CHECK: invoke.cont4:
+; CHECK:   invoke void @_ZN5InnerD1Ev(%class.Inner* %inner)
+; CHECK:           to label %invoke.cont5 unwind label %[[LPAD1_LABEL]]
+
+invoke.cont4:                                     ; preds = %invoke.cont2
+  invoke void @_ZN5InnerD1Ev(%class.Inner* %inner)
+          to label %invoke.cont5 unwind label %lpad1
+
+; CHECK: invoke.cont5:
+; CHECK:   br label %try.cont
+
+invoke.cont5:                                     ; preds = %invoke.cont4
+  br label %try.cont
+
+; CHECK: [[LPAD_LABEL]]:
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           catch i8* bitcast (i8** @_ZTIf to i8*)
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD_VAL]], i32 0, i8* bitcast (i8** @_ZTIf to i8*), float* %f, i8* bitcast (i8* (i8*, i8*)* @_Z4testv.catch to i8*))
+; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont19]
+
+lpad:                                             ; preds = %try.cont, %entry
+  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+          catch i8* bitcast (i8** @_ZTIf to i8*)
+  %tmp1 = extractvalue { i8*, i32 } %tmp, 0
+  store i8* %tmp1, i8** %exn.slot
+  %tmp2 = extractvalue { i8*, i32 } %tmp, 1
+  store i32 %tmp2, i32* %ehselector.slot
+  br label %catch.dispatch11
+
+; CHECK: [[LPAD1_LABEL]]:
+; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           cleanup
+; CHECK:           catch i8* bitcast (i8** @_ZTIi to i8*)
+; CHECK:           catch i8* bitcast (i8** @_ZTIf to i8*)
+; CHECK:   [[RECOVER1:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD1_VAL]], i32 0, i8* bitcast (i8** @_ZTIi to i8*), i32* %i, i8* bitcast (i8* (i8*, i8*)* @_Z4testv.catch1 to i8*), i32 1, i8* bitcast (void (i8*, i8*)* @_Z4testv.cleanup to i8*), i32 0, i8* bitcast (i8** @_ZTIf to i8*), float* %f, i8* bitcast (i8* (i8*, i8*)* @_Z4testv.catch to i8*))
+; CHECK:   indirectbr i8* [[RECOVER1]], [label %try.cont, label %try.cont19]
+
+lpad1:                                            ; preds = %invoke.cont4, %invoke.cont
+  %tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+          cleanup
+          catch i8* bitcast (i8** @_ZTIi to i8*)
+          catch i8* bitcast (i8** @_ZTIf to i8*)
+  %tmp4 = extractvalue { i8*, i32 } %tmp3, 0
+  store i8* %tmp4, i8** %exn.slot
+  %tmp5 = extractvalue { i8*, i32 } %tmp3, 1
+  store i32 %tmp5, i32* %ehselector.slot
+  br label %catch.dispatch
+
+; CHECK: [[LPAD3_LABEL]]:
+; CHECK:   [[LPAD3_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           cleanup
+; CHECK:           catch i8* bitcast (i8** @_ZTIi to i8*)
+; CHECK:           catch i8* bitcast (i8** @_ZTIf to i8*)
+; CHECK-NOT:   extractvalue { i8*, i32 }
+; CHECK-NOT:   store i8*
+; CHECK-NOT:   store i32
+; CHECK-NOT:   call void @_ZN5InnerD1Ev(%class.Inner* %inner)
+; CHECK:   [[RECOVER3:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD3_VAL]], i32 1, i8* bitcast (void (i8*, i8*)* @_Z4testv.cleanup2 to i8*), i32 0, i8* bitcast (i8** @_ZTIi to i8*), i32* %i, i8* bitcast (i8* (i8*, i8*)* @_Z4testv.catch1 to i8*), i32 1, i8* bitcast (void (i8*, i8*)* @_Z4testv.cleanup to i8*), i32 0, i8* bitcast (i8** @_ZTIf to i8*), float* %f, i8* bitcast (i8* (i8*, i8*)* @_Z4testv.catch to i8*))
+; CHECK:   indirectbr i8* [[RECOVER3]], [label %try.cont, label %try.cont19]
+
+lpad3:                                            ; preds = %invoke.cont2
+  %tmp6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+          cleanup
+          catch i8* bitcast (i8** @_ZTIi to i8*)
+          catch i8* bitcast (i8** @_ZTIf to i8*)
+  %tmp7 = extractvalue { i8*, i32 } %tmp6, 0
+  store i8* %tmp7, i8** %exn.slot
+  %tmp8 = extractvalue { i8*, i32 } %tmp6, 1
+  store i32 %tmp8, i32* %ehselector.slot
+  call void @_ZN5InnerD1Ev(%class.Inner* %inner)
+  br label %catch.dispatch
+
+; CHECK-NOT: catch.dispatch:
+
+catch.dispatch:                                   ; preds = %lpad3, %lpad1
+  %sel = load i32, i32* %ehselector.slot
+  %tmp9 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) #4
+  %matches = icmp eq i32 %sel, %tmp9
+  br i1 %matches, label %catch, label %ehcleanup
+
+; CHECK-NOT: catch:
+
+catch:                                            ; preds = %catch.dispatch
+  %exn = load i8*, i8** %exn.slot
+  %i.i8 = bitcast i32* %i to i8*
+  call void @llvm.eh.begincatch(i8* %exn, i8* %i.i8) #4
+  %tmp13 = load i32, i32* %i, align 4
+  invoke void @_Z10handle_inti(i32 %tmp13)
+          to label %invoke.cont8 unwind label %lpad7
+
+; CHECK-NOT: invoke.cont8:
+
+invoke.cont8:                                     ; preds = %catch
+  call void @llvm.eh.endcatch() #4
+  br label %try.cont
+
+; CHECK: try.cont:
+; CHECK:   invoke void @_ZN5OuterD1Ev(%class.Outer* %outer)
+; CHECK:           to label %invoke.cont9 unwind label %[[LPAD_LABEL]]
+
+try.cont:                                         ; preds = %invoke.cont8, %invoke.cont5
+  invoke void @_ZN5OuterD1Ev(%class.Outer* %outer)
+          to label %invoke.cont9 unwind label %lpad
+
+invoke.cont9:                                     ; preds = %try.cont
+  br label %try.cont19
+
+; CHECK-NOT: lpad7:
+
+lpad7:                                            ; preds = %catch
+  %tmp14 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+          cleanup
+          catch i8* bitcast (i8** @_ZTIf to i8*)
+  %tmp15 = extractvalue { i8*, i32 } %tmp14, 0
+  store i8* %tmp15, i8** %exn.slot
+  %tmp16 = extractvalue { i8*, i32 } %tmp14, 1
+  store i32 %tmp16, i32* %ehselector.slot
+  call void @llvm.eh.endcatch() #4
+  br label %ehcleanup
+
+; CHECK-NOT: ehcleanup:                                        ; preds = %lpad7, %catch.dispatch
+
+ehcleanup:                                        ; preds = %lpad7, %catch.dispatch
+  call void @_ZN5OuterD1Ev(%class.Outer* %outer)
+  br label %catch.dispatch11
+
+; CHECK-NOT: catch.dispatch11:
+
+catch.dispatch11:                                 ; preds = %ehcleanup, %lpad
+  %sel12 = load i32, i32* %ehselector.slot
+  %tmp17 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIf to i8*)) #4
+  %matches13 = icmp eq i32 %sel12, %tmp17
+  br i1 %matches13, label %catch14, label %eh.resume
+
+; CHECK-NOT: catch14:
+
+catch14:                                          ; preds = %catch.dispatch11
+  %exn15 = load i8*, i8** %exn.slot
+  %f.i8 = bitcast float* %f to i8*
+  call void @llvm.eh.begincatch(i8* %exn15, i8* %f.i8) #4
+  %tmp21 = load float, float* %f, align 4
+  call void @_Z12handle_floatf(float %tmp21)
+  call void @llvm.eh.endcatch() #4
+  br label %try.cont19
+
+try.cont19:                                       ; preds = %catch14, %invoke.cont9
+  call void @_Z4donev()
+  ret void
+
+; CHECK-NOT: eh.resume:
+
+eh.resume:                                        ; preds = %catch.dispatch11
+  %exn20 = load i8*, i8** %exn.slot
+  %sel21 = load i32, i32* %ehselector.slot
+  %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn20, 0
+  %lpad.val22 = insertvalue { i8*, i32 } %lpad.val, i32 %sel21, 1
+  resume { i8*, i32 } %lpad.val22
+
+; CHECK: }
+}
+
+; This catch handler should be outlined.
+; CHECK: define internal i8* @_Z4testv.catch(i8*, i8*) {
+; CHECK: entry:
+; CHECK:   [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 0)
+; CHECK:   [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float*
+; CHECK:   [[TMP:\%.+]] = load float, float* [[F_PTR]], align 4
+; CHECK:   call void @_Z12handle_floatf(float [[TMP]])
+; CHECK:   ret i8* blockaddress(@_Z4testv, %try.cont19)
+; CHECK: }
+
+; This catch handler should be outlined.
+; CHECK: define internal i8* @_Z4testv.catch1(i8*, i8*) {
+; CHECK: entry:
+; CHECK:   [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 1)
+; CHECK:   [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
+; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
+; CHECK:   invoke void @_Z10handle_inti(i32 [[TMP1]])
+; CHECK:           to label %invoke.cont8 unwind label %[[LPAD7_LABEL:lpad[0-9]*]]
+;
+; CHECK: invoke.cont8:                                     ; preds = %entry
+; CHECK:   ret i8* blockaddress(@_Z4testv, %try.cont)
+;
+; CHECK: [[LPAD7_LABEL]]:{{[ ]+}}; preds = %entry
+; CHECK:   [[LPAD7_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; (FIXME) The nested handler body isn't being populated yet.
+; CHECK: }
+
+; This cleanup handler should be outlined.
+; CHECK: define internal void @_Z4testv.cleanup(i8*, i8*) {
+; CHECK: entry:
+; CHECK:   [[RECOVER_OUTER:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 2)
+; CHECK:   [[OUTER_PTR:\%.+]] = bitcast i8* [[RECOVER_OUTER]] to %class.Outer*
+; CHECK:   call void @_ZN5OuterD1Ev(%class.Outer* [[OUTER_PTR]])
+; CHECK:   ret void
+; CHECK: }
+
+; This cleanup handler should be outlined.
+; CHECK: define internal void @_Z4testv.cleanup2(i8*, i8*) {
+; CHECK: entry:
+; CHECK:   [[RECOVER_INNER:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 3)
+; CHECK:   [[INNER_PTR:\%.+]] = bitcast i8* [[RECOVER_INNER]] to %class.Inner*
+; CHECK:   call void @_ZN5InnerD1Ev(%class.Inner* [[INNER_PTR]])
+; CHECK:   ret void
+; CHECK: }
+
+
+
+declare void @_ZN5OuterC1Ev(%class.Outer*) #1
+
+declare i32 @__CxxFrameHandler3(...)
+
+declare void @_ZN5InnerC1Ev(%class.Inner*) #1
+
+declare void @_Z9may_throwv() #1
+
+declare void @_ZN5InnerD1Ev(%class.Inner*) #1
+
+declare void @llvm.eh.begincatch(i8*, i8*)
+
+; Function Attrs: nounwind readnone
+declare i32 @llvm.eh.typeid.for(i8*) #3
+
+declare void @_Z10handle_inti(i32) #1
+
+declare void @llvm.eh.endcatch()
+
+declare void @_ZN5OuterD1Ev(%class.Outer*) #1
+
+declare void @_Z12handle_floatf(float) #1
+
+declare void @_Z4donev() #1
+
+attributes #0 = { uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { noinline noreturn nounwind }
+attributes #3 = { nounwind readnone }
+attributes #4 = { nounwind }
+attributes #5 = { noreturn nounwind }
+
+!llvm.ident = !{!0}
+
+!0 = !{!"clang version 3.7.0 (trunk 226027)"}

test/CodeGen/WinEH/cppeh-nonalloca-frame-values.ll

 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 
 ; The function entry should be rewritten like this.
 ; CHECK: define void @"\01?test@@YAXXZ"() #0 {
 ; CHECK: entry:
-; CHECK:   %NumExceptions.020.reg2mem = alloca i32
-; CHECK:   %i.019.reg2mem = alloca i32
-; CHECK:   %e = alloca i32, align 4
-; CHECK:   %ExceptionVal = alloca [10 x i32], align 16
-; CHECK:   %Data = alloca i64, align 8
-; CHECK:   %tmpcast = bitcast i64* %Data to %struct.SomeData*
-; CHECK:   %0 = bitcast [10 x i32]* %ExceptionVal to i8*
-; CHECK:   call void @llvm.lifetime.start(i64 40, i8* %0) #1
-; CHECK:   store i64 0, i64* %Data, align 8
-; CHECK:   %a.reg2mem = alloca i32*
-; CHECK:   %a = bitcast i64* %Data to i32*
-; CHECK:   store i32* %a, i32** %a.reg2mem
-; CHECK:   %b.reg2mem = alloca i32*
-; CHECK:   %b = getelementptr inbounds %struct.SomeData, %struct.SomeData* %tmpcast, i64 0, i32 1
-; CHECK:   store i32* %b, i32** %b.reg2mem
-; CHECK:   store i32 0, i32* %NumExceptions.020.reg2mem
-; CHECK:   store i32 0, i32* %i.019.reg2mem
-; CHECK:   call void (...)* @llvm.frameescape(i32* %e, i32* %NumExceptions.020.reg2mem, [10 x i32]* %ExceptionVal, i32* %i.019.reg2mem, i32** %a.reg2mem, i32** %b.reg2mem)
+; CHECK:   [[NUMEXCEPTIONS_REGMEM:\%.+]] = alloca i32
+; CHECK:   [[I_REGMEM:\%.+]] = alloca i32
+; CHECK:   [[E_PTR:\%.+]] = alloca i32, align 4
+; CHECK:   [[EXCEPTIONVAL:\%.+]] = alloca [10 x i32], align 16
+; CHECK:   [[DATA_PTR:\%.+]] = alloca i64, align 8
+; CHECK:   [[TMPCAST:\%.+]] = bitcast i64* [[DATA_PTR]] to %struct.SomeData*
+; CHECK:   [[TMP:\%.+]] = bitcast [10 x i32]* [[EXCEPTIONVAL]] to i8*
+; CHECK:   call void @llvm.lifetime.start(i64 40, i8* [[TMP]])
+; CHECK:   store i64 0, i64* [[DATA_PTR]], align 8
+; CHECK:   [[A_REGMEM:\%.+]] = alloca i32*
+; CHECK:   [[A_PTR:\%.+]] = bitcast i64* [[DATA_PTR]] to i32*
+; CHECK:   store i32* [[A_PTR]], i32** [[A_REGMEM]]
+; CHECK:   [[B_PTR:\%.+]] = getelementptr inbounds %struct.SomeData, %struct.SomeData* [[TMPCAST]], i64 0, i32 1
+; CHECK:   [[B_REGMEM:\%.+]] = alloca i32*
+; CHECK:   store i32* [[B_PTR]], i32** [[B_REGMEM]]
+; CHECK:   store i32 0, i32* [[NUMEXCEPTIONS_REGMEM]]
+; CHECK:   store i32 0, i32* [[I_REGMEM]]
+; CHECK:   call void (...)* @llvm.frameescape(i32* %e, i32* %NumExceptions.020.reg2mem, [10 x i32]* [[EXCEPTIONVAL]], i32* [[I_REGMEM]], i32** [[A_REGMEM]], i32** [[B_REGMEM]])
 ; CHECK:   br label %for.body
 
 ; Function Attrs: uwtable
 define void @"\01?test@@YAXXZ"() #0 {
 entry:
   %e = alloca i32, align 4
   %ExceptionVal = alloca [10 x i32], align 16
   %Data = alloca i64, align 8
   %tmpcast = bitcast i64* %Data to %struct.SomeData*
   %0 = bitcast [10 x i32]* %ExceptionVal to i8*
   call void @llvm.lifetime.start(i64 40, i8* %0) #1
   store i64 0, i64* %Data, align 8
   %a = bitcast i64* %Data to i32*
   %b = getelementptr inbounds %struct.SomeData, %struct.SomeData* %tmpcast, i64 0, i32 1
   br label %for.body
 
 ; CHECK: for.body:
-; CHECK-NOT:  %NumExceptions.020 = phi i32 [ 0, %entry ], [ %NumExceptions.1, %try.cont ]
-; CHECK-NOT:  %i.019 = phi i32 [ 0, %entry ], [ %inc5, %try.cont ]
-; CHECK:  %i.019.reload = load i32, i32* %i.019.reg2mem
-; CHECK:  %NumExceptions.020.reload = load i32, i32* %NumExceptions.020.reg2mem
+; CHECK-NOT:  phi i32 [ 0, %entry ], [ {{\%NumExceptions.*}}, %try.cont ]
+; CHECK-NOT:  phi i32 [ 0, %entry ], [ {{\%inc.*}}, %try.cont ]
+; CHECK:  [[I_RELOAD:\%.+]] = load i32, i32* [[I_REGMEM]]
+; CHECK:  [[NUMEXCEPTIONS_RELOAD:\%.+]] = load i32, i32* [[NUMEXCEPTIONS_REGMEM]]
 for.body:                                         ; preds = %entry, %try.cont
   %NumExceptions.020 = phi i32 [ 0, %entry ], [ %NumExceptions.1, %try.cont ]
   %i.019 = phi i32 [ 0, %entry ], [ %inc5, %try.cont ]
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 ; CHECK: invoke.cont:                                      ; preds = %for.body
-; CHECK-NOT:  %1 = load i32, i32* %a, align 8, !tbaa !2
-; CHECK-NOT:  %add = add nsw i32 %1, %i.019
-; CHECK-NOT:  store i32 %add, i32* %a, align 8, !tbaa !2
-; CHECK:   %a.reload3 = load volatile i32*, i32** %a.reg2mem
-; CHECK:   %1 = load i32, i32* %a.reload3, align 8, !tbaa !2
-; CHECK:   %add = add nsw i32 %1, %i.019.reload
-; CHECK:   %a.reload2 = load volatile i32*, i32** %a.reg2mem
-; CHECK:   store i32 %add, i32* %a.reload2, align 8, !tbaa !2
+; CHECK:   [[A_RELOAD:\%.+]] = load volatile i32*, i32** [[A_REGMEM]]
+; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[A_RELOAD]], align 8
+; CHECK:   [[ADD:\%.+]] = add nsw i32 [[TMP1]], [[I_RELOAD]]
+; CHECK:   [[A_RELOAD1:\%.+]] = load volatile i32*, i32** [[A_REGMEM]]
+; CHECK:   store i32 [[ADD]], i32* [[A_RELOAD1]], align 8
 ; CHECK:   br label %try.cont
 invoke.cont:                                      ; preds = %for.body
   %1 = load i32, i32* %a, align 8, !tbaa !2
   %add = add nsw i32 %1, %i.019
   store i32 %add, i32* %a, align 8, !tbaa !2
   br label %try.cont
 
+; CHECK: [[LPAD_LABEL:lpad[0-9]*]]:{{[ ]+}}; preds = %for.body
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
+; CHECK-NOT:   extractvalue { i8*, i32 }
+; CHECK-NOT:   tail call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*))
+; CHECK-NOT:   icmp eq i32
+; CHECK-NOT:   br i1
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD_VAL]], i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* %e, i8* bitcast (i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch" to i8*))
+; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont]
+
 lpad:                                             ; preds = %for.body
   %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %3 = extractvalue { i8*, i32 } %2, 1
   %4 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)) #1
   %matches = icmp eq i32 %3, %4
   br i1 %matches, label %catch, label %eh.resume
 
+; CHECK-NOT: catch:
+
 catch:                                            ; preds = %lpad
   %5 = extractvalue { i8*, i32 } %2, 0
   %e.i8 = bitcast i32* %e to i8*
   call void @llvm.eh.begincatch(i8* %5, i8* %e.i8) #1
   %tmp8 = load i32, i32* %e, align 4, !tbaa !7
   %idxprom = sext i32 %NumExceptions.020 to i64
   %arrayidx = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i64 0, i64 %idxprom
   store i32 %tmp8, i32* %arrayidx, align 4, !tbaa !7
   %inc = add nsw i32 %NumExceptions.020, 1
   %cmp1 = icmp eq i32 %tmp8, %i.019
   br i1 %cmp1, label %if.then, label %if.else
 
+; CHECK-NOT: if.then:
+
 if.then:                                          ; preds = %catch
   %tmp9 = load i32, i32* %b, align 4, !tbaa !8
   %add2 = add nsw i32 %tmp9, %i.019
   store i32 %add2, i32* %b, align 4, !tbaa !8
   br label %if.end
 
+; CHECK-NOT: if.else:
+
 if.else:                                          ; preds = %catch
   %tmp10 = load i32, i32* %a, align 8, !tbaa !2
   %add4 = add nsw i32 %tmp10, %tmp8
   store i32 %add4, i32* %a, align 8, !tbaa !2
   br label %if.end
 
+; CHECK-NOT: if.end:
+
 if.end:                                           ; preds = %if.else, %if.then
   tail call void @llvm.eh.endcatch() #1
   br label %try.cont
 
-; CHECK: try.cont:                                         ; preds = %if.end, %invoke.cont
-; CHECK-NOT:  %NumExceptions.1 = phi i32 [ %NumExceptions.020, %invoke.cont ], [ %inc, %if.end ]
-; CHECK:   %NumExceptions.1 = phi i32 [ %NumExceptions.020.reload, %invoke.cont ], [ %inc, %if.end ]
-; CHECK:   tail call void @"\01?does_not_throw@@YAXH@Z"(i32 %NumExceptions.1)
-; CHECK-NOT:  %inc5 = add nuw nsw i32 %i.019, 1
-; CHECK:   %inc5 = add nuw nsw i32 %i.019.reload, 1
-; CHECK:   %cmp = icmp slt i32 %inc5, 10
-; CHECK:   store i32 %NumExceptions.1, i32* %NumExceptions.020.reg2mem
-; CHECK:   store i32 %inc5, i32* %i.019.reg2mem
-; CHECK:   br i1 %cmp, label %for.body, label %for.end
+; CHECK: try.cont:{{[ ]+}}; preds = %[[LPAD_LABEL]], %invoke.cont
+; CHECK-NOT:  phi i32
+; CHECK:   tail call void @"\01?does_not_throw@@YAXH@Z"(i32 [[NUMEXCEPTIONS_RELOAD]])
+; CHECK:   [[INC:\%.+]] = add nuw nsw i32 [[I_RELOAD]], 1
+; CHECK:   [[CMP:\%.+]] = icmp slt i32 [[INC]], 10
+; CHECK:   store i32 [[NUMEXCEPTIONS_RELOAD]], i32* [[NUMEXCEPTIONS_REGMEM]]
+; CHECK:   store i32 [[INC]], i32* [[I_REGMEM]]
+; CHECK:   br i1 [[CMP]], label %for.body, label %for.end
 
 try.cont:                                         ; preds = %if.end, %invoke.cont
   %NumExceptions.1 = phi i32 [ %NumExceptions.020, %invoke.cont ], [ %inc, %if.end ]
   tail call void @"\01?does_not_throw@@YAXH@Z"(i32 %NumExceptions.1)
   %inc5 = add nuw nsw i32 %i.019, 1
   %cmp = icmp slt i32 %inc5, 10
   br i1 %cmp, label %for.body, label %for.end
 
 for.end:                                          ; preds = %try.cont
   %NumExceptions.1.lcssa = phi i32 [ %NumExceptions.1, %try.cont ]
   %arraydecay = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i64 0, i64 0
   call void @"\01?dump@@YAXPEAHHAEAUSomeData@@@Z"(i32* %arraydecay, i32 %NumExceptions.1.lcssa, %struct.SomeData* dereferenceable(8) %tmpcast)
   call void @llvm.lifetime.end(i64 40, i8* %0) #1
   ret void
 
 eh.resume:                                        ; preds = %lpad
   %.lcssa = phi { i8*, i32 } [ %2, %lpad ]
   resume { i8*, i32 } %.lcssa
 }
 
 ; The following catch handler should be outlined.
 ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*) {
 ; CHECK: entry:
-; CHECK:   %e.i84 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
-; CHECK:   %e = bitcast i8* %e.i84 to i32*
-; CHECK:   %eh.temp.alloca.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
-; CHECK:   %eh.temp.alloca = bitcast i8* %eh.temp.alloca.i8 to i32*
-; CHECK:   %NumExceptions.020.reload = load i32, i32* %eh.temp.alloca
-; CHECK:   %ExceptionVal.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
-; CHECK:   %ExceptionVal = bitcast i8* %ExceptionVal.i8 to [10 x i32]*
-; CHECK:   %eh.temp.alloca1.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 3)
-; CHECK:   %eh.temp.alloca1 = bitcast i8* %eh.temp.alloca1.i8 to i32*
-; CHECK:   %i.019.reload = load i32, i32* %eh.temp.alloca1
-; CHECK:   %eh.temp.alloca2.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 4)
-; CHECK:   %eh.temp.alloca2 = bitcast i8* %eh.temp.alloca2.i8 to i32**
-; CHECK:   %a.reload = load i32*, i32** %eh.temp.alloca2
-; CHECK:   %eh.temp.alloca3.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 5)
-; CHECK:   %eh.temp.alloca3 = bitcast i8* %eh.temp.alloca3.i8 to i32**
-; CHECK:   %b.reload = load i32*, i32** %eh.temp.alloca3
-; CHECK:   %e.i8 = bitcast i32* %e to i8*
-; CHECK:   %tmp8 = load i32, i32* %e, align 4, !tbaa !7
-; CHECK:   %idxprom = sext i32 %NumExceptions.020.reload to i64
-; CHECK:   %arrayidx = getelementptr inbounds [10 x i32], [10 x i32]* %ExceptionVal, i64 0, i64 %idxprom
-; CHECK:   store i32 %tmp8, i32* %arrayidx, align 4, !tbaa !7
-; CHECK:   %inc = add nsw i32 %NumExceptions.020.reload, 1
-; CHECK:   %cmp1 = icmp eq i32 %tmp8, %i.019.reload
-; CHECK:   br i1 %cmp1, label %if.then, label %if.else
+; CHECK:   [[RECOVER_E:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
+; CHECK:   [[E_PTR:\%.+]] = bitcast i8* [[RECOVER_E]] to i32*
+; CHECK:   [[RECOVER_EH_TEMP:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
+; CHECK:   [[EH_TEMP:\%.+]] = bitcast i8* [[RECOVER_EH_TEMP]] to i32*
+; CHECK:   [[NUMEXCEPTIONS_RELOAD:\%.+]] = load i32, i32* [[EH_TEMP]]
+; CHECK:   [[RECOVER_EXCEPTIONVAL:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
+; CHECK:   [[EXCEPTIONVAL:\%.+]] = bitcast i8* [[RECOVER_EXCEPTIONVAL]] to [10 x i32]*
+; CHECK:   [[RECOVER_EH_TEMP1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 3)
+; CHECK:   [[EH_TEMP1:\%.+]] = bitcast i8* [[RECOVER_EH_TEMP1]] to i32*
+; CHECK:   [[I_RELOAD:\%.+]] = load i32, i32* [[EH_TEMP1]]
+; CHECK:   [[RECOVER_EH_TEMP2:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 4)
+; CHECK:   [[EH_TEMP2:\%.+]] = bitcast i8* [[RECOVER_EH_TEMP2]] to i32**
+; CHECK:   [[A_RELOAD:\%.+]] = load i32*, i32** [[EH_TEMP2]]
+; CHECK:   [[RECOVER_EH_TEMP3:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 5)
+; CHECK:   [[EH_TEMP3:\%.+]] = bitcast i8* [[RECOVER_EH_TEMP3]] to i32**
+; CHECK:   [[B_RELOAD:\%.+]] = load i32*, i32** [[EH_TEMP3]]
+; CHECK:   [[E_I8PTR:\%.+]] = bitcast i32* [[E_PTR]] to i8*
+; CHECK:   [[TMP:\%.+]] = load i32, i32* [[E_PTR]], align 4
+; CHECK:   [[IDXPROM:\%.+]] = sext i32 [[NUMEXCEPTIONS_RELOAD]] to i64
+; CHECK:   [[ARRAYIDX:\%.+]] = getelementptr inbounds [10 x i32], [10 x i32]* [[EXCEPTIONVAL]], i64 0, i64 [[IDXPROM]]
+; CHECK:   store i32 [[TMP]], i32* [[ARRAYIDX]], align 4
+; CHECK:   [[INC:\%.+]] = add nsw i32 [[NUMEXCEPTIONS_RELOAD]], 1
+; CHECK:   [[CMP:\%.+]] = icmp eq i32 [[TMP]], [[I_RELOAD]]
+; CHECK:   br i1 [[CMP]], label %if.then, label %if.else
 ;
-; CHECK: if.then:                                          ; preds = %entry
-; CHECK:   %tmp9 = load i32, i32* %b.reload, align 4, !tbaa !8
-; CHECK:   %add2 = add nsw i32 %tmp9, %i.019.reload
-; CHECK:   store i32 %add2, i32* %b.reload, align 4, !tbaa !8
+; CHECK: if.then:{{[ ]+}}; preds = %entry
+; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[B_RELOAD]], align 4
+; CHECK:   [[ADD:\%.+]] = add nsw i32 [[TMP1]], [[I_RELOAD]]
+; CHECK:   store i32 [[ADD]], i32* [[B_RELOAD]], align 4
 ; CHECK:   br label %if.end
 ;
-; CHECK: if.else:                                          ; preds = %entry
-; CHECK:   %tmp10 = load i32, i32* %a.reload, align 8, !tbaa !2
-; CHECK:   %add4 = add nsw i32 %tmp10, %tmp8
-; CHECK:   store i32 %add4, i32* %a.reload, align 8, !tbaa !2
+; CHECK: if.else:{{[ ]+}}; preds = %entry
+; CHECK:   [[TMP2:\%.+]] = load i32, i32* [[A_RELOAD]], align 8
+; CHECK:   [[ADD2:\%.+]] = add nsw i32 [[TMP2]], [[TMP]]
+; CHECK:   store i32 [[ADD2]], i32* [[A_RELOAD]], align 8
 ; CHECK:   br label %if.end
 ;
-; CHECK: if.end:                                           ; preds = %if.else, %if.then
+; CHECK: if.end:{{[ ]+}}; preds = %if.else, %if.then
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
 ; CHECK: }
 
 ; Function Attrs: nounwind
 declare void @llvm.lifetime.start(i64, i8* nocapture) #1
 
 declare void @"\01?may_throw@@YAXXZ"() #2