Index: llvm/trunk/include/llvm/Transforms/Utils/Cloning.h =================================================================== --- llvm/trunk/include/llvm/Transforms/Utils/Cloning.h +++ llvm/trunk/include/llvm/Transforms/Utils/Cloning.h @@ -135,6 +135,41 @@ 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() {} + virtual ~CloningDirector() {} + + /// Subclasses must override this function to customize cloning behavior. + virtual CloningAction handleInstruction(ValueToValueMapTy &VMap, + const Instruction *Inst, + BasicBlock *NewBB) = 0; +}; + +void CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc, + const Instruction *StartingInst, + ValueToValueMapTy &VMap, + bool ModuleLevelChanges, + SmallVectorImpl &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 Index: llvm/trunk/lib/CodeGen/WinEHPrepare.cpp =================================================================== --- llvm/trunk/lib/CodeGen/WinEHPrepare.cpp +++ llvm/trunk/lib/CodeGen/WinEHPrepare.cpp @@ -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 - -using namespace llvm; - -#define DEBUG_TYPE "winehprepare" - -namespace { -class WinEHPrepare : public FunctionPass { - std::unique_ptr 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 LPads; - SmallVector Resumes; - for (BasicBlock &BB : Fn) { - if (auto *LP = BB.getLandingPadInst()) - LPads.push_back(LP); - if (auto *Resume = dyn_cast(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 + +using namespace llvm; +using namespace llvm::PatternMatch; + +#define DEBUG_TYPE "winehprepare" + +namespace { +class WinEHPrepare : public FunctionPass { + std::unique_ptr 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 &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() {} + + CloningAction handleInstruction(ValueToValueMapTy &VMap, + const Instruction *Inst, + BasicBlock *NewBB) override; + +private: + LandingPadInst *LPI; + Function *CatchFn; + Value *CurrentSelector; + Value *EHObj; + Type *SelectorIDType; + Type *Int8PtrType; + + const Value *ExtractedEHPtr; + const Value *ExtractedSelector; + const Value *EHPtrStoreAddr; + const Value *SelectorStoreAddr; + const Value *EHObjStoreAddr; +}; +} // 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 LPads; + SmallVector Resumes; + for (BasicBlock &BB : Fn) { + if (auto *LP = BB.getLandingPadInst()) + LPads.push_back(LP); + if (auto *Resume = dyn_cast(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 &LPads) { + // FIXME: Find all frame variable references in the handlers + // to populate the structure elements. + SmallVector 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(&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 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 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(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(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(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())) { + // 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())) { + auto *IntrinCall = dyn_cast(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(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())) { + auto *IntrinCall = dyn_cast(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; +} Index: llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp +++ llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp @@ -260,21 +260,26 @@ 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 &ToClone); }; } @@ -282,6 +287,7 @@ /// 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 &ToClone){ WeakVH &BBEntry = VMap[BB]; @@ -307,14 +313,31 @@ const_cast(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 @@ // 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(OldTI)) { if (BI->isConditional()) { // If the condition was a known constant in the callee... @@ -409,39 +444,47 @@ } } -/// 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 &Returns, + SmallVectorImpl &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 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 @@ // 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(VMap[&OldFunc->getEntryBlock()]); + Function::iterator Begin = cast(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 @@ // 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(VMap[&OldFunc->getEntryBlock()]), + for (Function::iterator I = cast(VMap[StartingBB]), E = NewFunc->end(); I != E; ++I) if (ReturnInst *RI = dyn_cast(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 &Returns, + const char *NameSuffix, + ClonedCodeInfo *CodeInfo, + const DataLayout *DL, + Instruction *TheCall) { + CloneAndPruneIntoFromInst(NewFunc, OldFunc, OldFunc->front().begin(), + VMap, ModuleLevelChanges, Returns, NameSuffix, + CodeInfo, DL, nullptr); +} Index: llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll =================================================================== --- llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll +++ llvm/trunk/test/CodeGen/X86/cppeh-catch-all.ll @@ -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)"} Index: llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll =================================================================== --- llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll +++ llvm/trunk/test/CodeGen/X86/cppeh-catch-scalar.ll @@ -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" + +@_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)"}