maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

dos2unix the WinEH file and tests 

llvm-svn: 229735
This commit is contained in:
Reid Kleckner 2015-02-18 19:52:46 +00:00
parent 8551d25fa9
commit 4dd0304e34
3 changed files with 576 additions and 576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

782
llvm/lib/CodeGen/WinEHPrepare.cpp
View File

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

166
llvm/test/CodeGen/X86/cppeh-catch-all.ll
View File

@ -1,83 +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)"}
; 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)"}

204
llvm/test/CodeGen/X86/cppeh-catch-scalar.ll
View File

@ -1,102 +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)"}
; 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)"}