[llvm] r229715 - Adding implementation to outline C++ catch handlers for native Windows 64 exception handling.
David Blaikie
dblaikie at gmail.com
Wed Feb 18 10:58:42 PST 2015
On Wed, Feb 18, 2015 at 10:31 AM, Andrew Kaylor <andrew.kaylor at intel.com>
wrote:
> Author: akaylor
> Date: Wed Feb 18 12:31:51 2015
> New Revision: 229715
>
> URL: http://llvm.org/viewvc/llvm-project?rev=229715&view=rev
> Log:
> Adding implementation to outline C++ catch handlers for native Windows 64
> exception handling.
>
> Differential Revision: http://reviews.llvm.org/D7363
>
>
> Added:
> llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll
> llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll
> Modified:
> llvm/trunk/include/llvm/Transforms/Utils/Cloning.h
> llvm/trunk/lib/CodeGen/WinEHPrepare.cpp
> llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
>
Looks like some/all parts of this change have windows line endings - could
you fix that? (& update your source control client config to handle this in
the future - I forget what the right incantation is, though, but it's been
discussed before on the mailing list)
>
> Modified: llvm/trunk/include/llvm/Transforms/Utils/Cloning.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/Cloning.h?rev=229715&r1=229714&r2=229715&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/Transforms/Utils/Cloning.h (original)
> +++ llvm/trunk/include/llvm/Transforms/Utils/Cloning.h Wed Feb 18 12:31:51
> 2015
> @@ -135,6 +135,41 @@ void CloneFunctionInto(Function *NewFunc
> ValueMapTypeRemapper *TypeMapper = nullptr,
> ValueMaterializer *Materializer = nullptr);
>
> +/// A helper class used with CloneAndPruneIntoFromInst to change the
> default
> +/// behavior while instructions are being cloned.
> +class CloningDirector {
> +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
> + };
> +
> + CloningDirector() {}
>
^ this looks like the default/implicit ctor - do you need to provide it
here for any reason rather than just not specifying it and relying on the
implicit default?
> + virtual ~CloningDirector() {}
>
This could be "= default" at least, I think. (while still being virtual)
> +
> + /// Subclasses must override this function to customize cloning
> behavior.
> + virtual CloningAction handleInstruction(ValueToValueMapTy &VMap,
> + const Instruction *Inst,
> + BasicBlock *NewBB) = 0;
>
Weird whitespace here - try clang-format?
> +};
> +
> +void CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
> + const Instruction *StartingInst,
> + ValueToValueMapTy &VMap,
> + bool ModuleLevelChanges,
> + SmallVectorImpl<ReturnInst*> &Returns,
> + const char *NameSuffix = "",
> + ClonedCodeInfo *CodeInfo = nullptr,
> + const DataLayout *DL = nullptr,
> + CloningDirector *Director = nullptr);
> +
> +
> /// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto,
> /// except that it does some simple constant prop and DCE on the fly. The
> /// effect of this is to copy significantly less code in cases where (for
>
> Modified: llvm/trunk/lib/CodeGen/WinEHPrepare.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/WinEHPrepare.cpp?rev=229715&r1=229714&r2=229715&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/WinEHPrepare.cpp (original)
> +++ llvm/trunk/lib/CodeGen/WinEHPrepare.cpp Wed Feb 18 12:31:51 2015
> @@ -1,102 +1,395 @@
> -//===-- 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/Pass.h"
> -#include <memory>
> -
> -using namespace llvm;
> -
> -#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";
> - }
> -};
> -} // 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: 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);
> -}
> +//===-- 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, Function *CatchFn, Value
> *Selector,
> + Value *EHObj)
> + : LPI(LPI), CatchFn(CatchFn),
> + CurrentSelector(Selector->stripPointerCasts()), EHObj(EHObj),
> + SelectorIDType(Type::getInt32Ty(LPI->getContext())),
> + Int8PtrType(Type::getInt8PtrTy(LPI->getContext())) {}
> + virtual ~WinEHCatchDirector() {}
>
Not sure why this didn't get a -Winconsistent-missing-override, but in any
case the whole dtor could be omitted, it'll default to the right thing
(because the base dtor is already virtual, so far as I can tell).
> +
> + CloningAction handleInstruction(ValueToValueMapTy &VMap,
> + const Instruction *Inst,
> + BasicBlock *NewBB) override;
> +
> +private:
> + LandingPadInst *LPI;
> + Function *CatchFn;
>
-Wunused-private-field (I've committed a fix for this, and removed the ctor
parameter that was initializing it)
> + Value *CurrentSelector;
> + Value *EHObj;
> + Type *SelectorIDType;
> + Type *Int8PtrType;
> +
> + const Value *ExtractedEHPtr;
> + const Value *ExtractedSelector;
> + const Value *EHPtrStoreAddr;
> + const Value *SelectorStoreAddr;
> + const Value *EHObjStoreAddr;
>
Also unused and I've committed a fix to remove it.
> +};
> +} // 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, CatchHandler, 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;
> +}
>
> Modified: llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp?rev=229715&r1=229714&r2=229715&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp Wed Feb 18 12:31:51
> 2015
> @@ -260,21 +260,26 @@ namespace {
> const char *NameSuffix;
> ClonedCodeInfo *CodeInfo;
> const DataLayout *DL;
> + CloningDirector *Director;
> +
> public:
> PruningFunctionCloner(Function *newFunc, const Function *oldFunc,
> ValueToValueMapTy &valueMap,
> bool moduleLevelChanges,
> const char *nameSuffix,
> ClonedCodeInfo *codeInfo,
> - const DataLayout *DL)
> + const DataLayout *DL,
> + CloningDirector *Director)
> : NewFunc(newFunc), OldFunc(oldFunc),
> VMap(valueMap), ModuleLevelChanges(moduleLevelChanges),
> - NameSuffix(nameSuffix), CodeInfo(codeInfo), DL(DL) {
> + NameSuffix(nameSuffix), CodeInfo(codeInfo), DL(DL),
> + Director(Director) {
> }
>
> /// CloneBlock - The specified block is found to be reachable, clone
> it and
> /// anything that it can reach.
> - void CloneBlock(const BasicBlock *BB,
> + void CloneBlock(const BasicBlock *BB,
> + BasicBlock::const_iterator StartingInst,
> std::vector<const BasicBlock*> &ToClone);
> };
> }
> @@ -282,6 +287,7 @@ namespace {
> /// CloneBlock - The specified block is found to be reachable, clone it
> and
> /// anything that it can reach.
> void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
> + BasicBlock::const_iterator
> StartingInst,
> std::vector<const BasicBlock*>
> &ToClone){
> WeakVH &BBEntry = VMap[BB];
>
> @@ -307,14 +313,31 @@ void PruningFunctionCloner::CloneBlock(c
> const_cast<BasicBlock*>(BB));
> VMap[OldBBAddr] = BlockAddress::get(NewFunc, NewBB);
> }
> -
>
> bool hasCalls = false, hasDynamicAllocas = false, hasStaticAllocas =
> false;
> -
> +
> // Loop over all instructions, and copy them over, DCE'ing as we go.
> This
> // loop doesn't include the terminator.
> - for (BasicBlock::const_iterator II = BB->begin(), IE = --BB->end();
> + for (BasicBlock::const_iterator II = StartingInst, IE = --BB->end();
> II != IE; ++II) {
> + // If the "Director" remaps the instruction, don't clone it.
> + if (Director) {
> + CloningDirector::CloningAction Action
> + = Director->handleInstruction(VMap, II,
> 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 the cloning director says skip, continue to the next
> instruction.
> + // In this case, the cloning director is responsible for mapping the
> + // skipped instruction to some value that is defined in the new
> + // basic block.
> + if (Action == CloningDirector::SkipInstruction)
> + continue;
> + }
> +
> Instruction *NewInst = II->clone();
>
> // Eagerly remap operands to the newly cloned instruction, except for
> PHI
> @@ -354,6 +377,18 @@ void PruningFunctionCloner::CloneBlock(c
> // Finally, clone over the terminator.
> const TerminatorInst *OldTI = BB->getTerminator();
> bool TerminatorDone = false;
> + 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;
> + 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...
> @@ -409,39 +444,47 @@ void PruningFunctionCloner::CloneBlock(c
> }
> }
>
> -/// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto,
> -/// except that it does some simple constant prop and DCE on the fly. The
> -/// effect of this is to copy significantly less code in cases where (for
> -/// example) a function call with constant arguments is inlined, and those
> -/// constant arguments cause a significant amount of code in the callee
> to be
> -/// dead. Since this doesn't produce an exact copy of the input, it
> can't be
> -/// used for things like CloneFunction or CloneModule.
> -void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function
> *OldFunc,
> +/// CloneAndPruneIntoFromInst - This works like
> CloneAndPruneFunctionInto, except
> +/// that it does not clone the entire function. Instead it starts at an
> +/// instruction provided by the caller and copies (and prunes) only the
> code
> +/// reachable from that instruction.
> +void llvm::CloneAndPruneIntoFromInst(Function *NewFunc, const Function
> *OldFunc,
> + const Instruction *StartingInst,
> ValueToValueMapTy &VMap,
> bool ModuleLevelChanges,
> - SmallVectorImpl<ReturnInst*>
> &Returns,
> + SmallVectorImpl<ReturnInst *>
> &Returns,
> const char *NameSuffix,
> ClonedCodeInfo *CodeInfo,
> const DataLayout *DL,
> - Instruction *TheCall) {
> + CloningDirector *Director) {
> assert(NameSuffix && "NameSuffix cannot be null!");
> -
> +
> #ifndef NDEBUG
> - for (Function::const_arg_iterator II = OldFunc->arg_begin(),
> - E = OldFunc->arg_end(); II != E; ++II)
> - assert(VMap.count(II) && "No mapping from source argument
> specified!");
> + // If the cloning starts at the begining of the function, verify that
> + // the function arguments are mapped.
> + if (!StartingInst)
> + for (Function::const_arg_iterator II = OldFunc->arg_begin(),
> + E = OldFunc->arg_end(); II != E; ++II)
> + assert(VMap.count(II) && "No mapping from source argument
> specified!");
> #endif
>
> PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, ModuleLevelChanges,
> - NameSuffix, CodeInfo, DL);
> + NameSuffix, CodeInfo, DL, Director);
> + const BasicBlock *StartingBB;
> + if (StartingInst)
> + StartingBB = StartingInst->getParent();
> + else {
> + StartingBB = &OldFunc->getEntryBlock();
> + StartingInst = StartingBB->begin();
> + }
>
> // Clone the entry block, and anything recursively reachable from it.
> std::vector<const BasicBlock*> CloneWorklist;
> - CloneWorklist.push_back(&OldFunc->getEntryBlock());
> + PFC.CloneBlock(StartingBB, StartingInst, CloneWorklist);
> while (!CloneWorklist.empty()) {
> const BasicBlock *BB = CloneWorklist.back();
> CloneWorklist.pop_back();
> - PFC.CloneBlock(BB, CloneWorklist);
> + PFC.CloneBlock(BB, BB->begin(), CloneWorklist);
> }
>
> // Loop over all of the basic blocks in the old function. If the block
> was
> @@ -569,7 +612,7 @@ void llvm::CloneAndPruneFunctionInto(Fun
> // and zap unconditional fall-through branches. This happen all the
> time when
> // specializing code: code specialization turns conditional branches
> into
> // uncond branches, and this code folds them.
> - Function::iterator Begin =
> cast<BasicBlock>(VMap[&OldFunc->getEntryBlock()]);
> + Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB]);
> Function::iterator I = Begin;
> while (I != NewFunc->end()) {
> // Check if this block has become dead during inlining or other
> @@ -620,9 +663,30 @@ void llvm::CloneAndPruneFunctionInto(Fun
> // Make a final pass over the basic blocks from theh old function to
> gather
> // any return instructions which survived folding. We have to do this
> here
> // because we can iteratively remove and merge returns above.
> - for (Function::iterator I =
> cast<BasicBlock>(VMap[&OldFunc->getEntryBlock()]),
> + for (Function::iterator I = cast<BasicBlock>(VMap[StartingBB]),
> E = NewFunc->end();
> I != E; ++I)
> if (ReturnInst *RI = dyn_cast<ReturnInst>(I->getTerminator()))
> Returns.push_back(RI);
> }
> +
> +
> +/// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto,
> +/// except that it does some simple constant prop and DCE on the fly. The
> +/// effect of this is to copy significantly less code in cases where (for
> +/// example) a function call with constant arguments is inlined, and those
> +/// constant arguments cause a significant amount of code in the callee
> to be
> +/// dead. Since this doesn't produce an exact copy of the input, it
> can't be
> +/// used for things like CloneFunction or CloneModule.
> +void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function
> *OldFunc,
> + ValueToValueMapTy &VMap,
> + bool ModuleLevelChanges,
> + SmallVectorImpl<ReturnInst*>
> &Returns,
> + const char *NameSuffix,
> + ClonedCodeInfo *CodeInfo,
> + const DataLayout *DL,
> + Instruction *TheCall) {
> + CloneAndPruneIntoFromInst(NewFunc, OldFunc, OldFunc->front().begin(),
> + VMap, ModuleLevelChanges, Returns, NameSuffix,
> + CodeInfo, DL, nullptr);
> +}
>
> Added: llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll?rev=229715&view=auto
>
> ==============================================================================
> --- llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll (added)
> +++ llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll Wed Feb 18 12:31:51 2015
> @@ -0,0 +1,83 @@
> +; RUN: opt -mtriple=x86_64-pc-windows-msvc -winehprepare -S -o - < %s |
> FileCheck %s
> +
> +; This test is based on the following code:
> +;
> +; void test()
> +; {
> +; try {
> +; may_throw();
> +; } catch (...) {
> +; handle_exception();
> +; }
> +; }
> +;
> +; 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"
> +
> +; 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
> +
> +lpad: ; preds = %entry
> + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
> @__CxxFrameHandler3 to i8*)
> + catch i8* null
> + %1 = extractvalue { i8*, i32 } %0, 0
> + store i8* %1, i8** %exn.slot
> + %2 = extractvalue { i8*, i32 } %0, 1
> + store i32 %2, i32* %ehselector.slot
> + br label %catch
> +
> +catch: ; preds = %lpad
> + %exn = load i8** %exn.slot
> + %3 = call i8* @llvm.eh.begincatch(i8* %exn) #3
> + call void @_Z16handle_exceptionv()
> + br label %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: define i8* @_Z4testv.catch(i8*, i8*) {
> +; CHECK: catch.entry:
> +; CHECK: %eh.alloc = call i8* @llvm.framerecover(i8* bitcast (void ()*
> @_Z4testv to i8*), i8* %1)
> +; CHECK: %ehdata = bitcast i8* %eh.alloc to %struct._Z4testv.ehdata*
> +; CHECK: %eh.obj.ptr = getelementptr inbounds %struct._Z4testv.ehdata*
> %ehdata, i32 0, i32 1
> +; CHECK: %eh.obj = load i8** %eh.obj.ptr
> +; CHECK: call void @_Z16handle_exceptionv()
> +; CHECK: ret i8* blockaddress(@_Z4testv, %try.cont)
> +; CHECK: }
> +
> +declare void @_Z9may_throwv() #1
> +
> +declare i32 @__CxxFrameHandler3(...)
> +
> +declare i8* @llvm.eh.begincatch(i8*)
> +
> +declare void @_Z16handle_exceptionv() #1
> +
> +declare void @llvm.eh.endcatch()
> +
> +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 }
> +attributes #4 = { noreturn nounwind }
> +
> +!llvm.ident = !{!0}
> +
> +!0 = !{!"clang version 3.7.0 (trunk 226027)"}
>
> Added: llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll?rev=229715&view=auto
>
> ==============================================================================
> --- llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll (added)
> +++ llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll Wed Feb 18 12:31:51
> 2015
> @@ -0,0 +1,102 @@
> +; RUN: opt -mtriple=x86_64-pc-windows-msvc -winehprepare -S -o - < %s |
> FileCheck %s
> +
> +; This test is based on the following code:
> +;
> +; void test()
> +; {
> +; try {
> +; may_throw();
> +; } catch (int) {
> +; handle_int();
> +; }
> +; }
> +;
> +; 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 = 'cppeh-catch-scalar.cpp'
> +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
> +target triple = "x86_64-pc-windows-msvc"
> +
> + at _ZTIi = external constant i8*
> +
> +; 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
> +
> +lpad: ; preds = %entry
> + %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
> @__CxxFrameHandler3 to i8*)
> + catch i8* bitcast (i8** @_ZTIi to i8*)
> + %1 = extractvalue { i8*, i32 } %0, 0
> + store i8* %1, i8** %exn.slot
> + %2 = extractvalue { i8*, i32 } %0, 1
> + store i32 %2, i32* %ehselector.slot
> + br label %catch.dispatch
> +
> +catch.dispatch: ; preds = %lpad
> + %sel = load i32* %ehselector.slot
> + %3 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) #3
> + %matches = icmp eq i32 %sel, %3
> + br i1 %matches, label %catch, label %eh.resume
> +
> +catch: ; preds =
> %catch.dispatch
> + %exn11 = load i8** %exn.slot
> + %4 = call i8* @llvm.eh.begincatch(i8* %exn11) #3
> + %5 = bitcast i8* %4 to i32*
> + call void @_Z10handle_intv()
> + br label %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
> +
> +eh.resume: ; preds =
> %catch.dispatch
> + %exn3 = load i8** %exn.slot
> + %sel4 = load 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: define i8* @_Z4testv.catch(i8*, i8*) {
> +; CHECK: catch.entry:
> +; CHECK: %eh.alloc = call i8* @llvm.framerecover(i8* bitcast (void ()*
> @_Z4testv to i8*), i8* %1)
> +; CHECK: %ehdata = bitcast i8* %eh.alloc to %struct._Z4testv.ehdata*
> +; CHECK: %eh.obj.ptr = getelementptr inbounds %struct._Z4testv.ehdata*
> %ehdata, i32 0, i32 1
> +; CHECK: %eh.obj = load i8** %eh.obj.ptr
> +; CHECK: %2 = bitcast i8* %eh.obj to i32*
> +; CHECK: call void @_Z10handle_intv()
> +; CHECK: ret i8* blockaddress(@_Z4testv, %try.cont)
> +; CHECK: }
> +
> +declare void @_Z9may_throwv() #1
> +
> +declare i32 @__CxxFrameHandler3(...)
> +
> +; Function Attrs: nounwind readnone
> +declare i32 @llvm.eh.typeid.for(i8*) #2
> +
> +declare i8* @llvm.eh.begincatch(i8*)
> +
> +declare void @llvm.eh.endcatch()
> +
> +declare void @_Z10handle_intv() #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 = { nounwind readnone }
> +attributes #3 = { nounwind }
> +
> +!llvm.ident = !{!0}
> +
> +!0 = !{!"clang version 3.7.0 (trunk 227474) (llvm/trunk 227508)"}
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20150218/10559576/attachment.html>
More information about the llvm-commits
mailing list