dos2unix the WinEH file and tests

llvm-svn: 229735

1 files changed, 391 insertions, 391 deletions

diff --git a/llvm/lib/CodeGen/WinEHPrepare.cpp b/llvm/lib/CodeGen/WinEHPrepare.cpp
index c6f8d091bad..9ff982e6611 100644
--- a/llvm/lib/CodeGen/WinEHPrepare.cpp
+++ b/llvm/lib/CodeGen/WinEHPrepare.cpp
@@ -1,391 +1,391 @@
-//===-- WinEHPrepare - Prepare exception handling for code generation ---===//

-//

-//                     The LLVM Compiler Infrastructure

-//

-// This file is distributed under the University of Illinois Open Source

-// License. See LICENSE.TXT for details.

-//

-//===----------------------------------------------------------------------===//

-//

-// This pass lowers LLVM IR exception handling into something closer to what the

-// 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/Analysis/LibCallSemantics.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/Transforms/Utils/Cloning.h"

-#include "llvm/Transforms/Utils/Local.h"

-#include <memory>

-

-using namespace llvm;

-using namespace llvm::PatternMatch;

-

-#define DEBUG_TYPE "winehprepare"

-

-namespace {

-class WinEHPrepare : public FunctionPass {

-  std::unique_ptr<FunctionPass> DwarfPrepare;

-

-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 outlineCatchHandler(Function *SrcFn, Constant *SelectorType,

-                           LandingPadInst *LPad, StructType *EHDataStructTy);

-};

-

-class WinEHCatchDirector : public CloningDirector {

-public:

-  WinEHCatchDirector(LandingPadInst *LPI, Value *Selector, Value *EHObj)

-      : LPI(LPI), CurrentSelector(Selector->stripPointerCasts()), EHObj(EHObj),

-        SelectorIDType(Type::getInt32Ty(LPI->getContext())),

-        Int8PtrType(Type::getInt8PtrTy(LPI->getContext())) {}

-  virtual ~WinEHCatchDirector() {}

-

-  CloningAction handleInstruction(ValueToValueMapTy &VMap,

-                                  const Instruction *Inst,

-                                  BasicBlock *NewBB) override;

-

-private:

-  LandingPadInst *LPI;

-  Value *CurrentSelector;

-  Value *EHObj;

-  Type *SelectorIDType;

-  Type *Int8PtrType;

-

-  const Value *ExtractedEHPtr;

-  const Value *ExtractedSelector;

-  const Value *EHPtrStoreAddr;

-  const Value *SelectorStoreAddr;

-};

-} // end anonymous namespace

-

-char WinEHPrepare::ID = 0;

-INITIALIZE_TM_PASS(WinEHPrepare, "winehprepare", "Prepare Windows exceptions",

-                   false, false)

-

-FunctionPass *llvm::createWinEHPass(const TargetMachine *TM) {

-  return new WinEHPrepare(TM);

-}

-

-static bool isMSVCPersonality(EHPersonality Pers) {

-  return Pers == EHPersonality::MSVC_Win64SEH ||

-         Pers == EHPersonality::MSVC_CXX;

-}

-

-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()))

-      Resumes.push_back(Resume);

-  }

-

-  // No need to prepare functions that lack landing pads.

-  if (LPads.empty())

-    return false;

-

-  // Classify the personality to see what kind of preparation we need.

-  EHPersonality Pers = classifyEHPersonality(LPads.back()->getPersonalityFn());

-

-  // Delegate through to the DWARF pass if this is unrecognized.

-  if (!isMSVCPersonality(Pers))

-    return DwarfPrepare->runOnFunction(Fn);

-

-  // FIXME: This only returns true if the C++ EH handlers were outlined.

-  //        When that code is complete, it should always return whatever

-  //        prepareCPPEHHandlers returns.

-  if (Pers == EHPersonality::MSVC_CXX && prepareCPPEHHandlers(Fn, LPads))

-    return true;

-

-  // FIXME: SEH Cleanups are unimplemented. Replace them with unreachable.

-  if (Resumes.empty())

-    return false;

-

-  for (ResumeInst *Resume : Resumes) {

-    IRBuilder<>(Resume).CreateUnreachable();

-    Resume->eraseFromParent();

-  }

-

-  return true;

-}

-

-bool WinEHPrepare::doFinalization(Module &M) {

-  return DwarfPrepare->doFinalization(M);

-}

-

-void WinEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {

-  DwarfPrepare->getAnalysisUsage(AU);

-}

-

-bool WinEHPrepare::prepareCPPEHHandlers(

-    Function &F, SmallVectorImpl<LandingPadInst *> &LPads) {

-  // FIXME: Find all frame variable references in the handlers

-  //        to populate the structure elements.

-  SmallVector<Type *, 2> AllocStructTys;

-  AllocStructTys.push_back(Type::getInt32Ty(F.getContext()));   // EH state

-  AllocStructTys.push_back(Type::getInt8PtrTy(F.getContext())); // EH object

-  StructType *EHDataStructTy =

-      StructType::create(F.getContext(), AllocStructTys, 

-                         "struct." + F.getName().str() + ".ehdata");

-  bool HandlersOutlined = false;

-

-  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 (Call->getCalledFunction()->getName() == "llvm.eh.actions") {

-          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))

-        HandlersOutlined =

-            outlineCatchHandler(&F, LPad->getClause(Idx), LPad, EHDataStructTy);

-    } // End for each clause

-  }   // End for each landingpad

-

-  return HandlersOutlined;

-}

-

-bool WinEHPrepare::outlineCatchHandler(Function *SrcFn, Constant *SelectorType,

-                                       LandingPadInst *LPad,

-                                       StructType *EHDataStructTy) {

-  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);

-  FunctionType *FnType = FunctionType::get(Int8PtrType, ArgTys, false);

-  Function *CatchHandler = Function::Create(

-      FnType, GlobalVariable::ExternalLinkage, SrcFn->getName() + ".catch", M);

-

-  // Generate a standard prolog to setup the frame recovery structure.

-  IRBuilder<> Builder(Context);

-  BasicBlock *Entry = BasicBlock::Create(Context, "catch.entry");

-  CatchHandler->getBasicBlockList().push_front(Entry);

-  Builder.SetInsertPoint(Entry);

-  Builder.SetCurrentDebugLocation(LPad->getDebugLoc());

-

-  // The outlined handler will be called with the parent's frame pointer as

-  // its second argument. To enable the handler to access variables from

-  // the parent frame, we use that pointer to get locate a special block

-  // of memory that was allocated using llvm.eh.allocateframe for this

-  // purpose.  During the outlining process we will determine which frame

-  // variables are used in handlers and create a structure that maps these

-  // variables into the frame allocation block.

-  //

-  // The frame allocation block also contains an exception state variable

-  // used by the runtime and a pointer to the exception object pointer

-  // which will be filled in by the runtime for use in the handler.

-  Function *RecoverFrameFn =

-      Intrinsic::getDeclaration(M, Intrinsic::framerecover);

-  Value *RecoverArgs[] = {Builder.CreateBitCast(SrcFn, Int8PtrType, ""),

-                          &(CatchHandler->getArgumentList().back())};

-  CallInst *EHAlloc =

-      Builder.CreateCall(RecoverFrameFn, RecoverArgs, "eh.alloc");

-  Value *EHData =

-      Builder.CreateBitCast(EHAlloc, EHDataStructTy->getPointerTo(), "ehdata");

-  Value *EHObjPtr =

-      Builder.CreateConstInBoundsGEP2_32(EHData, 0, 1, "eh.obj.ptr");

-

-  // This will give us a raw pointer to the exception object, which

-  // corresponds to the formal parameter of the catch statement.  If the

-  // handler uses this object, we will generate code during the outlining

-  // process to cast the pointer to the appropriate type and deference it

-  // as necessary.  The un-outlined landing pad code represents the

-  // exception object as the result of the llvm.eh.begincatch call.

-  Value *EHObj = Builder.CreateLoad(EHObjPtr, false, "eh.obj");

-

-  ValueToValueMapTy VMap;

-

-  // FIXME: Map other values referenced in the filter handler.

-

-  WinEHCatchDirector Director(LPad, SelectorType, EHObj);

-

-  SmallVector<ReturnInst *, 8> Returns;

-  ClonedCodeInfo InlinedFunctionInfo;

-

-  BasicBlock::iterator II = LPad;

-

-  CloneAndPruneIntoFromInst(CatchHandler, SrcFn, ++II, VMap,

-                            /*ModuleLevelChanges=*/false, Returns, "",

-                            &InlinedFunctionInfo,

-                            SrcFn->getParent()->getDataLayout(), &Director);

-

-  // 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();

-

-  return true;

-}

-

-CloningDirector::CloningAction WinEHCatchDirector::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;

-      }

-

-      // Tell the caller not to clone this instruction.

-      return CloningDirector::SkipInstruction;

-    }

-    // Other extract value instructions just get cloned.

-    return CloningDirector::CloneInstruction;

-  }

-

-  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;

-    }

-

-    // Any other store just gets cloned.

-    return CloningDirector::CloneInstruction;

-  }

-

-  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);

-      return CloningDirector::SkipInstruction;

-    }

-    if (LoadAddr == SelectorStoreAddr) {

-      VMap[Inst] = ConstantInt::get(SelectorIDType, 1);

-      return CloningDirector::SkipInstruction;

-    }

-

-    // Any other loads just get cloned.

-    return CloningDirector::CloneInstruction;

-  }

-

-  if (match(Inst, m_Intrinsic<Intrinsic::eh_begincatch>())) {

-    // 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 return value of this instruction, however, is used to access the

-    // EH object pointer.  We have generated an instruction to get that value

-    // from the EH alloc block, so we can just map to that here.

-    VMap[Inst] = EHObj;

-    return CloningDirector::SkipInstruction;

-  }

-  if (match(Inst, m_Intrinsic<Intrinsic::eh_endcatch>())) {

-    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.

-    // 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);

-

-    // 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;

-  }

-  if (match(Inst, m_Intrinsic<Intrinsic::eh_typeid_for>())) {

-    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;

-  }

-

-  // Continue with the default cloning behavior.

-  return CloningDirector::CloneInstruction;

-}

+//===-- WinEHPrepare - Prepare exception handling for code generation ---===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass lowers LLVM IR exception handling into something closer to what the
+// 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/Analysis/LibCallSemantics.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/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/Local.h"
+#include <memory>
+
+using namespace llvm;
+using namespace llvm::PatternMatch;
+
+#define DEBUG_TYPE "winehprepare"
+
+namespace {
+class WinEHPrepare : public FunctionPass {
+  std::unique_ptr<FunctionPass> DwarfPrepare;
+
+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 outlineCatchHandler(Function *SrcFn, Constant *SelectorType,
+                           LandingPadInst *LPad, StructType *EHDataStructTy);
+};
+
+class WinEHCatchDirector : public CloningDirector {
+public:
+  WinEHCatchDirector(LandingPadInst *LPI, Value *Selector, Value *EHObj)
+      : LPI(LPI), CurrentSelector(Selector->stripPointerCasts()), EHObj(EHObj),
+        SelectorIDType(Type::getInt32Ty(LPI->getContext())),
+        Int8PtrType(Type::getInt8PtrTy(LPI->getContext())) {}
+  virtual ~WinEHCatchDirector() {}
+
+  CloningAction handleInstruction(ValueToValueMapTy &VMap,
+                                  const Instruction *Inst,
+                                  BasicBlock *NewBB) override;
+
+private:
+  LandingPadInst *LPI;
+  Value *CurrentSelector;
+  Value *EHObj;
+  Type *SelectorIDType;
+  Type *Int8PtrType;
+
+  const Value *ExtractedEHPtr;
+  const Value *ExtractedSelector;
+  const Value *EHPtrStoreAddr;
+  const Value *SelectorStoreAddr;
+};
+} // end anonymous namespace
+
+char WinEHPrepare::ID = 0;
+INITIALIZE_TM_PASS(WinEHPrepare, "winehprepare", "Prepare Windows exceptions",
+                   false, false)
+
+FunctionPass *llvm::createWinEHPass(const TargetMachine *TM) {
+  return new WinEHPrepare(TM);
+}
+
+static bool isMSVCPersonality(EHPersonality Pers) {
+  return Pers == EHPersonality::MSVC_Win64SEH ||
+         Pers == EHPersonality::MSVC_CXX;
+}
+
+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()))
+      Resumes.push_back(Resume);
+  }
+
+  // No need to prepare functions that lack landing pads.
+  if (LPads.empty())
+    return false;
+
+  // Classify the personality to see what kind of preparation we need.
+  EHPersonality Pers = classifyEHPersonality(LPads.back()->getPersonalityFn());
+
+  // Delegate through to the DWARF pass if this is unrecognized.
+  if (!isMSVCPersonality(Pers))
+    return DwarfPrepare->runOnFunction(Fn);
+
+  // FIXME: This only returns true if the C++ EH handlers were outlined.
+  //        When that code is complete, it should always return whatever
+  //        prepareCPPEHHandlers returns.
+  if (Pers == EHPersonality::MSVC_CXX && prepareCPPEHHandlers(Fn, LPads))
+    return true;
+
+  // FIXME: SEH Cleanups are unimplemented. Replace them with unreachable.
+  if (Resumes.empty())
+    return false;
+
+  for (ResumeInst *Resume : Resumes) {
+    IRBuilder<>(Resume).CreateUnreachable();
+    Resume->eraseFromParent();
+  }
+
+  return true;
+}
+
+bool WinEHPrepare::doFinalization(Module &M) {
+  return DwarfPrepare->doFinalization(M);
+}
+
+void WinEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {
+  DwarfPrepare->getAnalysisUsage(AU);
+}
+
+bool WinEHPrepare::prepareCPPEHHandlers(
+    Function &F, SmallVectorImpl<LandingPadInst *> &LPads) {
+  // FIXME: Find all frame variable references in the handlers
+  //        to populate the structure elements.
+  SmallVector<Type *, 2> AllocStructTys;
+  AllocStructTys.push_back(Type::getInt32Ty(F.getContext()));   // EH state
+  AllocStructTys.push_back(Type::getInt8PtrTy(F.getContext())); // EH object
+  StructType *EHDataStructTy =
+      StructType::create(F.getContext(), AllocStructTys, 
+                         "struct." + F.getName().str() + ".ehdata");
+  bool HandlersOutlined = false;
+
+  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 (Call->getCalledFunction()->getName() == "llvm.eh.actions") {
+          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))
+        HandlersOutlined =
+            outlineCatchHandler(&F, LPad->getClause(Idx), LPad, EHDataStructTy);
+    } // End for each clause
+  }   // End for each landingpad
+
+  return HandlersOutlined;
+}
+
+bool WinEHPrepare::outlineCatchHandler(Function *SrcFn, Constant *SelectorType,
+                                       LandingPadInst *LPad,
+                                       StructType *EHDataStructTy) {
+  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);
+  FunctionType *FnType = FunctionType::get(Int8PtrType, ArgTys, false);
+  Function *CatchHandler = Function::Create(
+      FnType, GlobalVariable::ExternalLinkage, SrcFn->getName() + ".catch", M);
+
+  // Generate a standard prolog to setup the frame recovery structure.
+  IRBuilder<> Builder(Context);
+  BasicBlock *Entry = BasicBlock::Create(Context, "catch.entry");
+  CatchHandler->getBasicBlockList().push_front(Entry);
+  Builder.SetInsertPoint(Entry);
+  Builder.SetCurrentDebugLocation(LPad->getDebugLoc());
+
+  // The outlined handler will be called with the parent's frame pointer as
+  // its second argument. To enable the handler to access variables from
+  // the parent frame, we use that pointer to get locate a special block
+  // of memory that was allocated using llvm.eh.allocateframe for this
+  // purpose.  During the outlining process we will determine which frame
+  // variables are used in handlers and create a structure that maps these
+  // variables into the frame allocation block.
+  //
+  // The frame allocation block also contains an exception state variable
+  // used by the runtime and a pointer to the exception object pointer
+  // which will be filled in by the runtime for use in the handler.
+  Function *RecoverFrameFn =
+      Intrinsic::getDeclaration(M, Intrinsic::framerecover);
+  Value *RecoverArgs[] = {Builder.CreateBitCast(SrcFn, Int8PtrType, ""),
+                          &(CatchHandler->getArgumentList().back())};
+  CallInst *EHAlloc =
+      Builder.CreateCall(RecoverFrameFn, RecoverArgs, "eh.alloc");
+  Value *EHData =
+      Builder.CreateBitCast(EHAlloc, EHDataStructTy->getPointerTo(), "ehdata");
+  Value *EHObjPtr =
+      Builder.CreateConstInBoundsGEP2_32(EHData, 0, 1, "eh.obj.ptr");
+
+  // This will give us a raw pointer to the exception object, which
+  // corresponds to the formal parameter of the catch statement.  If the
+  // handler uses this object, we will generate code during the outlining
+  // process to cast the pointer to the appropriate type and deference it
+  // as necessary.  The un-outlined landing pad code represents the
+  // exception object as the result of the llvm.eh.begincatch call.
+  Value *EHObj = Builder.CreateLoad(EHObjPtr, false, "eh.obj");
+
+  ValueToValueMapTy VMap;
+
+  // FIXME: Map other values referenced in the filter handler.
+
+  WinEHCatchDirector Director(LPad, SelectorType, EHObj);
+
+  SmallVector<ReturnInst *, 8> Returns;
+  ClonedCodeInfo InlinedFunctionInfo;
+
+  BasicBlock::iterator II = LPad;
+
+  CloneAndPruneIntoFromInst(CatchHandler, SrcFn, ++II, VMap,
+                            /*ModuleLevelChanges=*/false, Returns, "",
+                            &InlinedFunctionInfo,
+                            SrcFn->getParent()->getDataLayout(), &Director);
+
+  // 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();
+
+  return true;
+}
+
+CloningDirector::CloningAction WinEHCatchDirector::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;
+      }
+
+      // Tell the caller not to clone this instruction.
+      return CloningDirector::SkipInstruction;
+    }
+    // Other extract value instructions just get cloned.
+    return CloningDirector::CloneInstruction;
+  }
+
+  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;
+    }
+
+    // Any other store just gets cloned.
+    return CloningDirector::CloneInstruction;
+  }
+
+  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);
+      return CloningDirector::SkipInstruction;
+    }
+    if (LoadAddr == SelectorStoreAddr) {
+      VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
+      return CloningDirector::SkipInstruction;
+    }
+
+    // Any other loads just get cloned.
+    return CloningDirector::CloneInstruction;
+  }
+
+  if (match(Inst, m_Intrinsic<Intrinsic::eh_begincatch>())) {
+    // 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 return value of this instruction, however, is used to access the
+    // EH object pointer.  We have generated an instruction to get that value
+    // from the EH alloc block, so we can just map to that here.
+    VMap[Inst] = EHObj;
+    return CloningDirector::SkipInstruction;
+  }
+  if (match(Inst, m_Intrinsic<Intrinsic::eh_endcatch>())) {
+    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.
+    // 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);
+
+    // 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;
+  }
+  if (match(Inst, m_Intrinsic<Intrinsic::eh_typeid_for>())) {
+    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;
+  }
+
+  // Continue with the default cloning behavior.
+  return CloningDirector::CloneInstruction;
+}