Handle nested landing pads in outlined catch handlers for Windows C++ EH

[andrew.w.kaylor]

Summary

This patch implements the code to fill in nested landing pads that were stubbed out during initial catch handler outlining.

The nested landing pad may introduce new exception variables that need to be recovered in the handler in which the landing pad is nested in order for the value to be passed to eh.actions. If the variable isn't otherwise referenced in the handler, I think we will want to drop the recovered value during code gen.

A catch handler that is called from the nested landing pad may need to return to an address in the outlined handler. I've added code to detect this case and remap the return instruction. This will not work correctly if the cloning code optimizes away the target block or if the target block is shared between multiple catch handlers. I think both of these are possible, but I don't have test cases to show it yet.

[rnk]

lib/CodeGen/WinEHPrepare.cpp

99

Can you add a comment about which is the key and which is the value? This goes from cloned LP to original LP if I read the code right. Maybe ClonedLPToOriginalLP would be a better name.

479

I *think* LPadPair.second = NewLPad will update the container. The subscript operation is making me nervous because it looks like mutation during iteration, even though we already know that the key exists in the container. DenseMap doesn't have this bug, but just the other day we were looking at an old implementation of TR1 hash_map which had a bug where it would potentially resize on this exact operation.

537

In general, you shouldn't need to reach for getInstList(). This can be written:

assert(&OutlinedBB->back() == OutlinedLPad);

558

You could probably just cast the result of the clone() call and save a local variable.

562–564

I have an idea for how we can completely eliminate the need for this. What if we changed the catch object argument from an AllocaInst to the i32 value that would be used with llvm.framerecover? That way the i32 would mean the same thing in the parent function and the child functions.

575

break?

585

Both the AllocaInst and Function cases of are pretty heavy. What do you think of pulling them out into helper functions? prepareExceptionHandlers is pretty long.

586–591

We have a parseEHActions function implementation in a pending patch. It goes from llvm.eh.actions call back into a list of ActionHandlers. It may ultimately be cleaner to use that, but I don't want to block your patch on ours. Let's throw a FIXME in here to come around and do that.

592

You can exit early if it's not i8*.

600–601

You can continue if it's not ReturnInst

608

Ditto, continue

888–893

These "End" comments seem excessive, for this short of a loop.

1196–1198

I wouldn't say "We shouldn't encounter landing pads in the actual cleanup code." This is currently only true because the outlining process unconditionally turns invokes in cleanups into calls. In general, destructors with real invokes can be inlined, and we will need to handle that one day. For now, I would rephrase this comment along the lines of "Cleanup outlining currently demotes all invokes to calls, so all landingpads are trivially unreachable."

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

99

I'm not sure ClonedLPToOriginalLP is especially helpful, as it doesn't indicate why the landing pads in question were mapped.

I do agree that something needs to be done to make this more clear and that a comment doesn't seem quite sufficient.

How about NestedLPToOriginalLP?

Incidentally, I did the mapping in this way because I think that it is possible for the same landing pad to be nested within multiple handlers.

479

Alright, I'll give that a try.

562–564

Yeah, that should work and would clean up a lot of mess here. It's not as readable, but hopefully no one will be reading these things much anyway.

575

Yes, if we have to keep this code.

585

Sounds reasonable.

586–591

OK

888–893

I just really hate seeing that many consecutive end brackets. They'll go away after I clean up the loops as you suggest above.

1196–1198

You mentioned this before, and I think I said then that I don't believe the MS runtime will allow an exception to be thrown in a cleanup handler. Do you disagree?

[andrew.w.kaylor]

Implemented suggested changes from earlier review.

[rnk]

This seems pretty close to done. Sorry for the delay, I was staring at .xdata tables all day long. =P

lib/CodeGen/WinEHPrepare.cpp

100–119

Thanks, these comments help. :)

777–778

parseEHActions is in tree in FunctionLoweringInfo, but if we share this code, we should probably move it over to this pass and declare it in WinEHFuncInfo.h.

Do you want to do this now or later? I'm OK either way.

782–803

Going forward, I would really like to change llvm.eh.actions to take an i32 frameescape index for the catch object instead. Doing this actually makes things easier for WinEHNumbering, which is where we build the try block map entries.

If we make this change first, you can remove this entire alloca case, because the index is the same in the parent function as in the outlined handler. Do you think it's worth defering this again, or would you rather try to get this in first and come back later?

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

777–778

It probably doesn't make sense to check in code that's going to be removed almost immediately. I'm in the process of merging this patch with the latest trunk revision now. I'll go ahead and make this change while I'm at it.

782–803

If the changes to frameescape can be made quickly, I think it's best to have that in first.

[andrew.w.kaylor]

Rebased to merge with latest WinEH changes.
Moved parseEHActions into WinEHPrepare and updated it to save the exception object frameescape index.
Updated the code that was previously parsing eh.actions calls in a different way.

[majnemer]

lib/CodeGen/WinEHPrepare.cpp

779

Can you please clarify this FIXME?

[andrew.w.kaylor]

lib/CodeGen/WinEHPrepare.cpp

779

Oops. That was there from a previous revision. It should have been deleted.

[majnemer]

include/llvm/CodeGen/WinEHFuncInfo.h

77 ↗

(On Diff #23188)

There is no getExceptionVarIndex and code which loads from ExceptionObjectIndex. Is this code from a prior revision or do you have future intentions for it?

[andrew.w.kaylor]

include/llvm/CodeGen/WinEHFuncInfo.h

77 ↗

(On Diff #23188)

I expected that the code generating the .xdata tables would use that, but I didn't want to add the function until it was going to be called.

[andrew.w.kaylor]

Adding updates to cppeh-prepared-catch.ll, which I missed previously.
Removing stale FIXME comment.

[rnk]

lgtm

lib/CodeGen/WinEHPrepare.cpp

785

Early continue if !Handler?

lib/CodeGen/WinEHPrepare.cpp

 class LandingPadMap;
 
 typedef DenseMap<const BasicBlock *, CatchHandler *> CatchHandlerMapTy;
 typedef DenseMap<const BasicBlock *, CleanupHandler *> CleanupHandlerMapTy;
 
 class WinEHPrepare : public FunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid.
-  WinEHPrepare(const TargetMachine *TM = nullptr)
-      : FunctionPass(ID) {}
+  WinEHPrepare(const TargetMachine *TM = nullptr) : FunctionPass(ID) {}
 
   bool runOnFunction(Function &Fn) override;
 
   bool doFinalization(Module &M) override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
   const char *getPassName() const override {
private:
   CleanupHandler *findCleanupHandler(BasicBlock *StartBB, BasicBlock *EndBB);
 
   void processSEHCatchHandler(CatchHandler *Handler, BasicBlock *StartBB);
 
   // All fields are reset by runOnFunction.
   EHPersonality Personality;
   CatchHandlerMapTy CatchHandlerMap;
   CleanupHandlerMapTy CleanupHandlerMap;
-  DenseMap<const LandingPadInst *, LandingPadMap>  LPadMaps;
+  DenseMap<const LandingPadInst *, LandingPadMap> LPadMaps;
+  DenseMap<LandingPadInst *, const LandingPadInst *> NestedLandingPads;
+  DenseMap<const BasicBlock *, BasicBlock *> LPadTargetBlocks;
 };
 
 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);
private:
   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(Function *HandlerFn,
-                           FrameVarInfoMap &VarInfo,
+  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,
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;
+  virtual CloningAction handleLandingPad(ValueToValueMapTy &VMap,
+                                         const LandingPadInst *LPad,
+                                         BasicBlock *NewBB) = 0;
 
   ValueMaterializer *getValueMaterializer() override { return &Materializer; }
 
 protected:
   WinEHFrameVariableMaterializer Materializer;
   Type *SelectorIDType;
   Type *Int8PtrType;
   LandingPadMap &LPadMap;
 };
 
 class WinEHCatchDirector : public WinEHCloningDirectorBase {
 public:
-  WinEHCatchDirector(Function *CatchFn, Value *Selector,
-                     FrameVarInfoMap &VarInfo, LandingPadMap &LPadMap)
+  WinEHCatchDirector(
+      Function *CatchFn, Value *Selector, FrameVarInfoMap &VarInfo,
+      LandingPadMap &LPadMap,
+      DenseMap<LandingPadInst *, const LandingPadInst *> &NestedLPads)
       : WinEHCloningDirectorBase(CatchFn, VarInfo, LPadMap),
         CurrentSelector(Selector->stripPointerCasts()),
-        ExceptionObjectVar(nullptr) {}
+        ExceptionObjectVar(nullptr), NestedLandingPads(NestedLPads) {}
 
   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;
+  CloningAction handleLandingPad(ValueToValueMapTy &VMap,
+                                 const LandingPadInst *LPad,
+                                 BasicBlock *NewBB) override;
 
   const Value *getExceptionVar() { return ExceptionObjectVar; }
   TinyPtrVector<BasicBlock *> &getReturnTargets() { return ReturnTargets; }
 
 private:
   Value *CurrentSelector;
 
   const Value *ExceptionObjectVar;
   TinyPtrVector<BasicBlock *> ReturnTargets;
+  DenseMap<LandingPadInst *, const LandingPadInst *> &NestedLandingPads;
 };
 
 class WinEHCleanupDirector : public WinEHCloningDirectorBase {
 public:
-  WinEHCleanupDirector(Function *CleanupFn,
-                       FrameVarInfoMap &VarInfo, LandingPadMap &LPadMap)
+  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;
+  CloningAction handleLandingPad(ValueToValueMapTy &VMap,
+                                 const LandingPadInst *LPad,
+                                 BasicBlock *NewBB) override;
 };
 
 class ActionHandler {
 public:
   ActionHandler(BasicBlock *BB, ActionType Type)
       : StartBB(BB), Type(Type), HandlerBlockOrFunc(nullptr) {}
 
   ActionType getType() const { return Type; }
INITIALIZE_TM_PASS(WinEHPrepare, "winehprepare", "Prepare Windows exceptions",
                    false, false)
 
 FunctionPass *llvm::createWinEHPass(const TargetMachine *TM) {
   return new WinEHPrepare(TM);
 }
 
 // FIXME: Remove this once the backend can handle the prepared IR.
 static cl::opt<bool>
     SEHPrepare("sehprepare", cl::Hidden,
                cl::desc("Prepare functions with SEH personalities"));
 
 bool WinEHPrepare::runOnFunction(Function &Fn) {
   SmallVector<LandingPadInst *, 4> LPads;
   SmallVector<ResumeInst *, 4> Resumes;
   for (BasicBlock &BB : Fn) {
     if (auto *LP = BB.getLandingPadInst())
       LPads.push_back(LP);
     if (auto *Resume = dyn_cast<ResumeInst>(BB.getTerminator()))
if (isAsynchronousEHPersonality(Personality) && !SEHPrepare) {
     return true;
   }
 
   // If there were any landing pads, prepareExceptionHandlers will make changes.
   prepareExceptionHandlers(Fn, LPads);
   return true;
 }
 
-bool WinEHPrepare::doFinalization(Module &M) {
-  return false;
-}
+bool WinEHPrepare::doFinalization(Module &M) { return false; }
 
 void WinEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {}
 
 bool WinEHPrepare::prepareExceptionHandlers(
     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.
for (LandingPadInst *LPad : LPads) {
     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);
     }
 
+    // Replace the mapping of any nested landing pad that previously mapped
+    // to this landing pad with a referenced to the cloned version.
+    for (auto &LPadPair : NestedLandingPads) {
+      const LandingPadInst *OriginalLPad = LPadPair.second;
+      if (OriginalLPad == LPad) {
+        NestedLandingPads[LPadPair.first] = cast<LandingPadInst>(NewLPad);
+      }
+    }
+
     // Replace uses of the old lpad in phis with this block and delete the old
     // block.
     LPadBB->replaceSuccessorsPhiUsesWith(NewLPadBB);
     LPadBB->getTerminator()->eraseFromParent();
     new UnreachableInst(LPadBB->getContext(), LPadBB);
 
     // Add a call to describe the actions for this landing pad.
     std::vector<Value *> ActionArgs;
for (ActionHandler *Action : Actions) {
       }
     }
   } // End for each landingpad
 
   // If nothing got outlined, there is no more processing to be done.
   if (!HandlersOutlined)
     return false;
 
+  // Replace any nested landing pad stubs with the correct action handler.
+  // This must be done before we remove unreachable blocks because it
+  // cleans up references to outlined blocks that will be deleted.
+  for (auto &LPadPair : NestedLandingPads) {
+    const LandingPadInst *OriginalLPad = LPadPair.second;
+    LandingPadInst *OutlinedLPad = LPadPair.first;
+
+    // Get the nested block and erase the unreachable instruction that was
+    // temporarily inserted as its terminator.
+    BasicBlock *OutlinedBB = OutlinedLPad->getParent();
+    assert(isa<UnreachableInst>(OutlinedBB->getTerminator()));
+    OutlinedBB->getTerminator()->eraseFromParent();
+    // That should leave OutlinedLPad as the last instruction in its block.
+    assert(&(OutlinedBB->getInstList().back()) == OutlinedLPad);
+
+    // The original landing pad will have already had its action intrinsic
+    // built by the outlining loop.  We need to clone that into the outlined
+    // location.  It may also be necessary to add references to the exception
+    // variables to the outlined handler in which this landing pad is nested
+    // and remap return instructions in the nested handlers that should return
+    // to an address in the outlined handler.
+    Function *OutlinedHandlerFn = OutlinedBB->getParent();
+    const BasicBlock *OriginalBB = OriginalLPad->getParent();
+    BasicBlock::const_iterator II = OriginalLPad;
+    ++II;
+    // The instruction after the landing pad should now be a call to eh.actions.
+    const Instruction *Recover = II;
+    assert(match(Recover, m_Intrinsic<Intrinsic::eh_actions>()));
+    Value *ClonedRecover = Recover->clone();
+
+    // Remap the exception variables into the outlined function.
+    WinEHFrameVariableMaterializer Materializer(OutlinedHandlerFn,
+                                                FrameVarInfo);
+    SmallVector<BlockAddress *, 4> ActionTargets;
+    CallInst *EHActions = cast<CallInst>(ClonedRecover);
+    unsigned NumArgs = EHActions->getNumArgOperands();
+    for (unsigned i = 0; i < NumArgs; ++i) {
+      Value *V = EHActions->getArgOperand(i);
+      // Find the exception variable operands and remap them into the
+      // outlined function. Exception variables should always have an alloca.
+      if (auto *AV = dyn_cast<AllocaInst>(V)) {
+        // See if this handler already has a copy of the needed value.
+        bool Found = false;
+        if (FrameVarInfo.count(AV)) {
+          // The FrameVarInfo map may contain references to this variable in
+          // multiple handler functions.  We need to iterate through them to
+          // see if one is in OutlinedHandlerFn.  If so, use that value in the
+          // eh.actions call.
+          for (auto *MappedAV : FrameVarInfo[AV]) {
+            if (MappedAV->getParent()->getParent() == OutlinedHandlerFn) {
+              EHActions->setArgOperand(i, MappedAV);
+              Found = true;
+            }
+          }
+        }
+        // If the value isn't already mapped into OutlinedHandlerFn, add it now
+        // and use the new value in the eh.actions call.
+        if (!Found) {
+          Value *NewVal = Materializer.materializeValueFor(V);
+          EHActions->setArgOperand(i, NewVal);
+        }
+      } else if (auto *HandlerArg = dyn_cast<Function>(V)) {
+        // This is checking for catch handler arguments. Cleanup handlers will
+        // have a void return type and filter functions will be bitcast to i8*.
+        // The return value alone is enough to identify an argument as a catch
+        // handler.  We could also pay attention to the sentinel value but that
+        // seems like more work than is necessary.
+        FunctionType *FnType = HandlerArg->getFunctionType();
+        if (FnType->getReturnType() == Int8PtrType) {
+          // Verify the rest of the function signature.
+          assert(FnType->getNumParams() == 2 &&
+                 FnType->getParamType(0) == Int8PtrType &&
+                 FnType->getParamType(1) == Int8PtrType);
+          // Visit all the return instructions, looking for places that return
+          // to a location within OutlinedHandlerFn.
+          for (BasicBlock &NestedHandlerBB : *HandlerArg) {
+            if (auto *Ret =
+                    dyn_cast<ReturnInst>(NestedHandlerBB.getTerminator())) {
+              // Handler functions must always return a block address.
+              BlockAddress *BA = cast<BlockAddress>(Ret->getReturnValue());
+              // The original target will have been in the main parent function,
+              // but if it is the address of a block that has been outlined, it
+              // should be a block that was outlined into OutlinedHandlerFn.
+              assert(BA->getFunction() == &F);
+              if (LPadTargetBlocks.count(BA->getBasicBlock())) {
+                // If the return value is the address of a block that we
+                // previously outlined into the parent handler function, replace
+                // the return instruction and add the mapped target to the list
+                // of possible return addresses.
+                BasicBlock *MappedBB = LPadTargetBlocks[BA->getBasicBlock()];
+                assert(MappedBB->getParent() == OutlinedHandlerFn);
+                BlockAddress *NewBA =
+                    BlockAddress::get(OutlinedHandlerFn, MappedBB);
+                Ret->eraseFromParent();
+                ReturnInst::Create(Context, NewBA, &NestedHandlerBB);
+                ActionTargets.push_back(NewBA);
+              }
+              // Ignore targets that aren't part of OutlinedHandlerFn.
+            } // End if terminator is ReturnInst
+          }   // End for (BasicBlock &NestedHandlerBB : *HandlerArg)
+        }     // End if HandlerArg is catch
+      }       // End else if arg is Function*
+    }         // End for EHActions args
+    OutlinedBB->getInstList().push_back(EHActions);
+
+    // Insert an indirect branch into the outlined landing pad BB.
+    IndirectBrInst *IndirectBr =
+        IndirectBrInst::Create(ClonedRecover, 0, OutlinedBB);
+    // Add the previously collected action targets.
+    for (auto *Target : ActionTargets)
+      IndirectBr->addDestination(Target->getBasicBlock());
+  }
+
   // Delete any blocks that were only used by handlers that were outlined above.
   removeUnreachableBlocks(F);
 
   BasicBlock *Entry = &F.getEntryBlock();
   IRBuilder<> Builder(F.getParent()->getContext());
   Builder.SetInsertPoint(Entry->getFirstInsertionPt());
 
   Function *FrameEscapeFn =
static bool isSelectorDispatch(BasicBlock *BB, BasicBlock *&CatchHandler,
 
   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 (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;
 
   ValueToValueMapTy VMap;
 
   LandingPadMap &LPadMap = LPadMaps[LPad];
   if (!LPadMap.isInitialized())
     LPadMap.mapLandingPad(LPad);
   if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
     Constant *Sel = CatchAction->getSelector();
-    Director.reset(new WinEHCatchDirector(Handler, Sel, VarInfo, LPadMap));
+    Director.reset(new WinEHCatchDirector(Handler, Sel, VarInfo, LPadMap,
+                                          NestedLandingPads));
     LPadMap.remapSelector(VMap, ConstantInt::get(Type::getInt32Ty(Context), 1));
   } else {
     Director.reset(new WinEHCleanupDirector(Handler, VarInfo, LPadMap));
   }
 
   SmallVector<ReturnInst *, 8> Returns;
   ClonedCodeInfo OutlinedFunctionInfo;
 
bool WinEHPrepare::outlineHandler(ActionHandler *Action, Function *SrcFn,
   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());
-  }
+
+    // Look for blocks that are not part of the landing pad that we just
+    // outlined but terminate with a call to llvm.eh.endcatch and a
+    // branch to a block that is in the handler we just outlined.
+    // These blocks will be part of a nested landing pad that intends to
+    // return to an address in this handler.  This case is best handled
+    // after both landing pads have been outlined, so for now we'll just
+    // save the association of the blocks in LPadTargetBlocks.  The
+    // return instructions which are created from these branches will be
+    // replaced after all landing pads have been outlined.
+    for (auto &MapEntry : VMap) {
+      // VMap maps all values and blocks that were just cloned, but dead
+      // blocks which were pruned will map to nullptr.
+      if (isa<BasicBlock>(MapEntry.first) && MapEntry.second != nullptr) {
+        const BasicBlock *MappedBB = cast<BasicBlock>(MapEntry.first);
+        for (auto *Pred : predecessors(const_cast<BasicBlock *>(MappedBB))) {
+          auto *Branch = dyn_cast<BranchInst>(Pred->getTerminator());
+          if (Branch && Branch->isUnconditional() && Pred->size() > 1) {
+            BasicBlock::iterator II = const_cast<BranchInst *>(Branch);
+            --II;
+            if (match(cast<Value>(II), m_Intrinsic<Intrinsic::eh_endcatch>())) {
+              // This would indicate that a nested landing pad wants to return
+              // to a block that is outlined into two different handlers.
+              assert(!LPadTargetBlocks.count(MappedBB));
+              LPadTargetBlocks[MappedBB] = cast<BasicBlock>(MapEntry.second);
+            } // End if (match(II, eh_endcatch))
+          }   // End if (UnconditionalBr)
+        }     // End for (predecessors)
+      }       // End if (MapEntry is a BB in the handler)
+    }         // End for VMap entries
+  }           // End if (CatchAction)
 
   Action->setHandlerBlockOrFunc(Handler);
 
   return true;
 }
 
 /// This BB must end in a selector dispatch. All we need to do is pass the
 /// handler block to llvm.eh.actions and list it as a possible indirectbr
for (auto *Store : SelectorStores) {
     if (Inst == Store)
       return true;
   }
 
   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
CloningDirector::CloningAction WinEHCloningDirectorBase::handleInstruction(
   }
 
   // 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;
+    return handleLandingPad(VMap, NestedLPad, NewBB);
   }
 
   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::handleLandingPad(ValueToValueMapTy &VMap,
+                                     const LandingPadInst *NestedLPad,
+                                     BasicBlock *NewBB) {
+  Instruction *NewInst = NestedLPad->clone();
+  if (NestedLPad->hasName())
+    NewInst->setName(NestedLPad->getName());
+  // Save this correlation for later processing.
+  NestedLandingPads[cast<LandingPadInst>(NewInst)] = NestedLPad;
+  VMap[NestedLPad] = NewInst;
+  BasicBlock::InstListType &InstList = NewBB->getInstList();
+  InstList.push_back(NewInst);
+  InstList.push_back(new UnreachableInst(NewBB->getContext()));
+  return CloningDirector::StopCloningBB;
+}
+
 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.
WinEHCatchDirector::handleEndCatch(ValueToValueMapTy &VMap,
   // 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.
+  // unconditional branch instruction that we want to replace it with a return
+  // to the the address of the branch target.  If at any point the target block
+  // is outlined into another handler function, the return value will be
+  // corrected after all landing pads have been outlined.
   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));
 
   BasicBlock *ContinueLabel = Branch->getSuccessor(0);
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::handleLandingPad(ValueToValueMapTy &VMap,
+                                       const LandingPadInst *NestedLPad,
+                                       BasicBlock *NewBB) {
+  // We shouldn't encounter landing pads in the actual cleanup code, but they
+  // will appear in catch blocks.  Depending on where we started cloning, we may
+  // see one, but it will get dropped during dead block pruning.
+  Instruction *NewInst = new UnreachableInst(NewBB->getContext());
+  VMap[NestedLPad] = NewInst;
+  BasicBlock::InstListType &InstList = NewBB->getInstList();
+  InstList.push_back(NewInst);
+  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::handleResume(
   // 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());
+  BasicBlock *EntryBB = &OutlinedFn->getEntryBlock();
+  Builder.SetInsertPoint(EntryBB, EntryBB->getFirstInsertionPt());
 }
 
 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
for (BasicBlock *Succ : successors(BB)) {
     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) {
+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.

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

 ;
 ; CHECK: invoke.cont6:                                     ; preds = %entry
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
 ;
 ; CHECK: [[LPAD5_LABEL]]:{{[ ]+}}; preds = %entry
 ; CHECK:   [[LPAD5_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:   unreachable
 ; CHECK: }
 
 declare %class.SomeClass* @"\01??0SomeClass@@QEAA@XZ"(%class.SomeClass* returned) #1
 
 declare i32 @__CxxFrameHandler3(...)
 
 declare void @"\01?may_throw@@YAXXZ"() #1
 

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

 ; RUN: opt -mtriple=x86_64-pc-windows-msvc -winehprepare -S -o - < %s | FileCheck %s
-; XFAIL: *
 
 ; This test is based on the following code:
 ;
 ;void test()
 ;{
 ;  try {
 ;    try {
 ;       may_throw();

 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:
 ; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
-; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions(i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* %i, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch" to i8*), i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* %f, i8* bitcast (i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* %i, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* %f, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
 ; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont, label %try.cont10]
 
 lpad:                                             ; preds = %entry
   %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
eh.resume:                                        ; %catch.dispatch3
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn11, 0
   %lpad.val13 = insertvalue { i8*, i32 } %lpad.val, i32 %sel12, 1
   resume { i8*, i32 } %lpad.val13
 ; CHECK: }
 }
 
 ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*) {
 ; CHECK: entry:
-; CHECK:   [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
-; CHECK:   [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
-; ------------================= FAIL here =================------------
 ; CHECK:   [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
 ; CHECK:   [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float*
+; CHECK:   [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
+; CHECK:   [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
 ; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
 ; CHECK:   invoke void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]])
 ; CHECK:           to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]]
 ;
 ; CHECK: invoke.cont2:
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
 ;
 ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry
 ; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
-; ------------================= FAIL here =================------------
-; CHECK:   [[RECOVER1:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD1_VAL]], i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* [[F_PTR]], i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
+; CHECK:   [[RECOVER1:\%.+]] = call i8* (...)* @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* [[F_PTR]], i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
 ; CHECK:   indirectbr i8* [[RECOVER1]], []
 ;
 ; CHECK: }
 
 ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) {
 ; CHECK: entry:
 ; CHECK:   [[RECOVER_F1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
 ; CHECK:   [[F_PTR1:\%.+]] = bitcast i8* [[RECOVER_F1]] to float*

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

 ; RUN: opt -mtriple=x86_64-pc-windows-msvc -winehprepare -S -o - < %s | FileCheck %s
-; XFAIL: *
 
 ; This test is based on the following code:
 ;
 ;void test()
 ;{
 ;  try {
 ;    try {
 ;       may_throw();

 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0M@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".M\00" }, comdat
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 
 ; CHECK: define void @"\01?test@@YAXXZ"() #0 {
 ; CHECK: entry:
 ; CHECK:   %i = alloca i32, align 4
-; ------------================= FAIL here =================------------
 ; CHECK:   %j = alloca i32, align 4
 ; CHECK:   %f = alloca float, align 4
-; ------------================= FAIL here =================------------
-; CHECK:   call void (...)* @llvm.frameescape(i32* %i, float* %f, int32* %j)
+; CHECK:   call void (...)* @llvm.frameescape(i32* %i, float* %f, i32* %j)
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
 define void @"\01?test@@YAXXZ"() #0 {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %i = alloca i32, align 4
   %j = alloca i32, align 4
   %f = alloca float, align 4
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont10
 
 ; CHECK: [[LPAD_LABEL]]:
 ; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
-; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions(i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* %i, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch" to i8*), i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* %f, i8* bitcast (i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
+; CHECK:   [[RECOVER:\%.+]] = call i8* (...)* @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* %i, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* %f, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
 ; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont10, label %try.cont19]
 
 lpad:                                             ; preds = %entry
   %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
eh.resume:                                        ; preds = %lpad16, %catch.dispatch11
   %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: }
 }
 
 ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*) {
 ; CHECK: entry:
-; CHECK:   [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
-; CHECK:   [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
-; ------------================= FAIL here =================------------
+; CHECK:   [[RECOVER_J:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
+; CHECK:   [[J_PTR:\%.+]] = bitcast i8* [[RECOVER_J]] to i32*
 ; CHECK:   [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
 ; CHECK:   [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float*
-; ------------================= FAIL here =================------------
-; CHECK:   [[RECOVER_J:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
-; CHECK:   [[J_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
+; CHECK:   [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
+; CHECK:   [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]]
 ;
-; CHECK: invoke.cont2:                                     ; preds = %entry
+; CHECK: invoke.cont2:                                     ; preds = %[[LPAD1_LABEL]], %entry
 ; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
 ; CHECK:   invoke void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]])
 ; CHECK:           to label %invoke.cont9 unwind label %[[LPAD8_LABEL:lpad[0-9]*]]
 ;
 ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry
 ; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
-; ------------================= FAIL here =================------------
-; CHECK:   [[RECOVER1:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD1_VAL]], i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* [[J_PTR]], i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch2" to i8*), i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* [[F_PTR1]], i8* bitcast (i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
-; CHECK:   indirectbr i8* [[RECOVER1]], []
+; CHECK:   [[RECOVER1:\%.+]] = call i8* (...)* @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32* [[J_PTR]], i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch2", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* [[F_PTR]], i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
+; CHECK:   indirectbr i8* [[RECOVER1]], [label %invoke.cont2]
 ;
 ; CHECK: invoke.cont9:
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10)
 ;
 ; CHECK: [[LPAD8_LABEL]]:{{[ ]+}}; preds = %invoke.cont2
 ; CHECK:   [[LPAD8_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
-; ------------================= FAIL here =================------------
-; CHECK:   [[RECOVER2:\%.+]] = call i8* (...)* @llvm.eh.actions({ i8*, i32 } [[LPAD8_VAL]], i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* [[F_PTR1]], i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
+; CHECK:   [[RECOVER2:\%.+]] = call i8* (...)* @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), float* [[F_PTR]], i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
 ; CHECK:   indirectbr i8* [[RECOVER2]], []
 ;
 ; CHECK: }
 
 ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) {
 ; CHECK: entry:
 ; CHECK:   [[RECOVER_F1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
 ; CHECK:   [[F_PTR1:\%.+]] = bitcast i8* [[RECOVER_F1]] to float*
 ; CHECK:   [[TMP2:\%.+]] = load float, float* [[F_PTR1]], align 4
 ; CHECK:   call void @"\01?handle_float@@YAXM@Z"(float [[TMP2]])
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont19)
 ; CHECK: }
 
 ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch2"(i8*, i8*) {
 ; CHECK: entry:
-; ------------================= FAIL here =================------------
-; SHOULD-CHECK:   [[J_PTR1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
+; CHECK:   [[RECOVER_J1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
+; CHECK:   [[J_PTR1:\%.+]] = bitcast i8* [[RECOVER_J1]] to i32*
 ; CHECK:   [[RECOVER_I1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
 ; CHECK:   [[I_PTR1:\%.+]] = bitcast i8* [[RECOVER_I1]] to i32*
 ; CHECK:   [[TMP3:\%.+]] = load i32, i32* [[J_PTR1]], align 4
 ; CHECK:   store i32 [[TMP3]], i32* [[I_PTR1]]
-; ------------================= FAIL here =================------------
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ.catch", %invoke.cont2)
 ; CHECK: }
 
 
 declare void @"\01?may_throw@@YAXXZ"() #1
 
 declare i32 @__CxxFrameHandler3(...)