mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-20 11:29:24 +00:00
Move include/Config and include/Support into include/llvm/Config, include/llvm/ADT and include/llvm/Support. From here on out, all LLVM public header files must be under include/llvm/. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16137 91177308-0d34-0410-b5e6-96231b3b80d8
404 lines
16 KiB
C++
404 lines
16 KiB
C++
//===- LowerInvoke.cpp - Eliminate Invoke & Unwind instructions -----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This transformation is designed for use by code generators which do not yet
|
|
// support stack unwinding. This pass supports two models of exception handling
|
|
// lowering, the 'cheap' support and the 'expensive' support.
|
|
//
|
|
// 'Cheap' exception handling support gives the program the ability to execute
|
|
// any program which does not "throw an exception", by turning 'invoke'
|
|
// instructions into calls and by turning 'unwind' instructions into calls to
|
|
// abort(). If the program does dynamically use the unwind instruction, the
|
|
// program will print a message then abort.
|
|
//
|
|
// 'Expensive' exception handling support gives the full exception handling
|
|
// support to the program at making the 'invoke' instruction really expensive.
|
|
// It basically inserts setjmp/longjmp calls to emulate the exception handling
|
|
// as necessary.
|
|
//
|
|
// Because the 'expensive' support slows down programs a lot, and EH is only
|
|
// used for a subset of the programs, it must be specifically enabled by an
|
|
// option.
|
|
//
|
|
// Note that after this pass runs the CFG is not entirely accurate (exceptional
|
|
// control flow edges are not correct anymore) so only very simple things should
|
|
// be done after the lowerinvoke pass has run (like generation of native code).
|
|
// This should not be used as a general purpose "my LLVM-to-LLVM pass doesn't
|
|
// support the invoke instruction yet" lowering pass.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Instructions.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include <csetjmp>
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
Statistic<> NumLowered("lowerinvoke", "Number of invoke & unwinds replaced");
|
|
cl::opt<bool> ExpensiveEHSupport("enable-correct-eh-support",
|
|
cl::desc("Make the -lowerinvoke pass insert expensive, but correct, EH code"));
|
|
|
|
class LowerInvoke : public FunctionPass {
|
|
// Used for both models.
|
|
Function *WriteFn;
|
|
Function *AbortFn;
|
|
Constant *AbortMessageInit;
|
|
Value *AbortMessage;
|
|
unsigned AbortMessageLength;
|
|
|
|
// Used for expensive EH support.
|
|
const Type *JBLinkTy;
|
|
GlobalVariable *JBListHead;
|
|
Function *SetJmpFn, *LongJmpFn;
|
|
public:
|
|
bool doInitialization(Module &M);
|
|
bool runOnFunction(Function &F);
|
|
private:
|
|
void writeAbortMessage(Instruction *IB);
|
|
bool insertCheapEHSupport(Function &F);
|
|
bool insertExpensiveEHSupport(Function &F);
|
|
};
|
|
|
|
RegisterOpt<LowerInvoke>
|
|
X("lowerinvoke", "Lower invoke and unwind, for unwindless code generators");
|
|
}
|
|
|
|
const PassInfo *llvm::LowerInvokePassID = X.getPassInfo();
|
|
|
|
// Public Interface To the LowerInvoke pass.
|
|
FunctionPass *llvm::createLowerInvokePass() { return new LowerInvoke(); }
|
|
|
|
// doInitialization - Make sure that there is a prototype for abort in the
|
|
// current module.
|
|
bool LowerInvoke::doInitialization(Module &M) {
|
|
const Type *VoidPtrTy = PointerType::get(Type::SByteTy);
|
|
AbortMessage = 0;
|
|
if (ExpensiveEHSupport) {
|
|
// Insert a type for the linked list of jump buffers. Unfortunately, we
|
|
// don't know the size of the target's setjmp buffer, so we make a guess.
|
|
// If this guess turns out to be too small, bad stuff could happen.
|
|
unsigned JmpBufSize = 200; // PPC has 192 words
|
|
assert(sizeof(jmp_buf) <= JmpBufSize*sizeof(void*) &&
|
|
"LowerInvoke doesn't know about targets with jmp_buf size > 200 words!");
|
|
const Type *JmpBufTy = ArrayType::get(VoidPtrTy, JmpBufSize);
|
|
|
|
{ // The type is recursive, so use a type holder.
|
|
std::vector<const Type*> Elements;
|
|
OpaqueType *OT = OpaqueType::get();
|
|
Elements.push_back(PointerType::get(OT));
|
|
Elements.push_back(JmpBufTy);
|
|
PATypeHolder JBLType(StructType::get(Elements));
|
|
OT->refineAbstractTypeTo(JBLType.get()); // Complete the cycle.
|
|
JBLinkTy = JBLType.get();
|
|
M.addTypeName("llvm.sjljeh.jmpbufty", JBLinkTy);
|
|
}
|
|
|
|
const Type *PtrJBList = PointerType::get(JBLinkTy);
|
|
|
|
// Now that we've done that, insert the jmpbuf list head global, unless it
|
|
// already exists.
|
|
if (!(JBListHead = M.getGlobalVariable("llvm.sjljeh.jblist", PtrJBList)))
|
|
JBListHead = new GlobalVariable(PtrJBList, false,
|
|
GlobalValue::LinkOnceLinkage,
|
|
Constant::getNullValue(PtrJBList),
|
|
"llvm.sjljeh.jblist", &M);
|
|
SetJmpFn = M.getOrInsertFunction("llvm.setjmp", Type::IntTy,
|
|
PointerType::get(JmpBufTy), 0);
|
|
LongJmpFn = M.getOrInsertFunction("llvm.longjmp", Type::VoidTy,
|
|
PointerType::get(JmpBufTy),
|
|
Type::IntTy, 0);
|
|
|
|
// The abort message for expensive EH support tells the user that the
|
|
// program 'unwound' without an 'invoke' instruction.
|
|
Constant *Msg =
|
|
ConstantArray::get("ERROR: Exception thrown, but not caught!\n");
|
|
AbortMessageLength = Msg->getNumOperands()-1; // don't include \0
|
|
AbortMessageInit = Msg;
|
|
|
|
GlobalVariable *MsgGV = M.getGlobalVariable("abort.msg", Msg->getType());
|
|
if (MsgGV && (!MsgGV->hasInitializer() || MsgGV->getInitializer() != Msg))
|
|
MsgGV = 0;
|
|
|
|
if (MsgGV) {
|
|
std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::LongTy));
|
|
AbortMessage =
|
|
ConstantExpr::getGetElementPtr(MsgGV, GEPIdx);
|
|
}
|
|
|
|
} else {
|
|
// The abort message for cheap EH support tells the user that EH is not
|
|
// enabled.
|
|
Constant *Msg =
|
|
ConstantArray::get("Exception handler needed, but not enabled. Recompile"
|
|
" program with -enable-correct-eh-support.\n");
|
|
AbortMessageLength = Msg->getNumOperands()-1; // don't include \0
|
|
AbortMessageInit = Msg;
|
|
|
|
GlobalVariable *MsgGV = M.getGlobalVariable("abort.msg", Msg->getType());
|
|
if (MsgGV && (!MsgGV->hasInitializer() || MsgGV->getInitializer() != Msg))
|
|
MsgGV = 0;
|
|
|
|
if (MsgGV) {
|
|
std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::LongTy));
|
|
AbortMessage =
|
|
ConstantExpr::getGetElementPtr(MsgGV, GEPIdx);
|
|
}
|
|
}
|
|
|
|
// We need the 'write' and 'abort' functions for both models.
|
|
AbortFn = M.getOrInsertFunction("abort", Type::VoidTy, 0);
|
|
|
|
// Unfortunately, 'write' can end up being prototyped in several different
|
|
// ways. If the user defines a three (or more) operand function named 'write'
|
|
// we will use their prototype. We _do not_ want to insert another instance
|
|
// of a write prototype, because we don't know that the funcresolve pass will
|
|
// run after us. If there is a definition of a write function, but it's not
|
|
// suitable for our uses, we just don't emit write calls. If there is no
|
|
// write prototype at all, we just add one.
|
|
if (Function *WF = M.getNamedFunction("write")) {
|
|
if (WF->getFunctionType()->getNumParams() > 3 ||
|
|
WF->getFunctionType()->isVarArg())
|
|
WriteFn = WF;
|
|
else
|
|
WriteFn = 0;
|
|
} else {
|
|
WriteFn = M.getOrInsertFunction("write", Type::VoidTy, Type::IntTy,
|
|
VoidPtrTy, Type::IntTy, 0);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void LowerInvoke::writeAbortMessage(Instruction *IB) {
|
|
if (WriteFn) {
|
|
if (!AbortMessage) {
|
|
GlobalVariable *MsgGV = new GlobalVariable(AbortMessageInit->getType(),
|
|
true,
|
|
GlobalValue::InternalLinkage,
|
|
AbortMessageInit, "abort.msg",
|
|
WriteFn->getParent());
|
|
std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::LongTy));
|
|
AbortMessage =
|
|
ConstantExpr::getGetElementPtr(MsgGV, GEPIdx);
|
|
}
|
|
|
|
// These are the arguments we WANT...
|
|
std::vector<Value*> Args;
|
|
Args.push_back(ConstantInt::get(Type::IntTy, 2));
|
|
Args.push_back(AbortMessage);
|
|
Args.push_back(ConstantInt::get(Type::IntTy, AbortMessageLength));
|
|
|
|
// If the actual declaration of write disagrees, insert casts as
|
|
// appropriate.
|
|
const FunctionType *FT = WriteFn->getFunctionType();
|
|
unsigned NumArgs = FT->getNumParams();
|
|
for (unsigned i = 0; i != 3; ++i)
|
|
if (i < NumArgs && FT->getParamType(i) != Args[i]->getType())
|
|
Args[i] = ConstantExpr::getCast(cast<Constant>(Args[i]),
|
|
FT->getParamType(i));
|
|
|
|
new CallInst(WriteFn, Args, "", IB);
|
|
}
|
|
}
|
|
|
|
bool LowerInvoke::insertCheapEHSupport(Function &F) {
|
|
bool Changed = false;
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) {
|
|
// Insert a normal call instruction...
|
|
std::string Name = II->getName(); II->setName("");
|
|
Value *NewCall = new CallInst(II->getCalledValue(),
|
|
std::vector<Value*>(II->op_begin()+3,
|
|
II->op_end()), Name,II);
|
|
II->replaceAllUsesWith(NewCall);
|
|
|
|
// Insert an unconditional branch to the normal destination.
|
|
new BranchInst(II->getNormalDest(), II);
|
|
|
|
// Remove any PHI node entries from the exception destination.
|
|
II->getUnwindDest()->removePredecessor(BB);
|
|
|
|
// Remove the invoke instruction now.
|
|
BB->getInstList().erase(II);
|
|
|
|
++NumLowered; Changed = true;
|
|
} else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->getTerminator())) {
|
|
// Insert a new call to write(2, AbortMessage, AbortMessageLength);
|
|
writeAbortMessage(UI);
|
|
|
|
// Insert a call to abort()
|
|
new CallInst(AbortFn, std::vector<Value*>(), "", UI);
|
|
|
|
// Insert a return instruction. This really should be a "barrier", as it
|
|
// is unreachable.
|
|
new ReturnInst(F.getReturnType() == Type::VoidTy ? 0 :
|
|
Constant::getNullValue(F.getReturnType()), UI);
|
|
|
|
// Remove the unwind instruction now.
|
|
BB->getInstList().erase(UI);
|
|
|
|
++NumLowered; Changed = true;
|
|
}
|
|
return Changed;
|
|
}
|
|
|
|
bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
|
|
bool Changed = false;
|
|
|
|
// If a function uses invoke, we have an alloca for the jump buffer.
|
|
AllocaInst *JmpBuf = 0;
|
|
|
|
// If this function contains an unwind instruction, two blocks get added: one
|
|
// to actually perform the longjmp, and one to terminate the program if there
|
|
// is no handler.
|
|
BasicBlock *UnwindBlock = 0, *TermBlock = 0;
|
|
std::vector<LoadInst*> JBPtrs;
|
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) {
|
|
if (JmpBuf == 0)
|
|
JmpBuf = new AllocaInst(JBLinkTy, 0, "jblink", F.begin()->begin());
|
|
|
|
// On the entry to the invoke, we must install our JmpBuf as the top of
|
|
// the stack.
|
|
LoadInst *OldEntry = new LoadInst(JBListHead, "oldehlist", II);
|
|
|
|
// Store this old value as our 'next' field, and store our alloca as the
|
|
// current jblist.
|
|
std::vector<Value*> Idx;
|
|
Idx.push_back(Constant::getNullValue(Type::IntTy));
|
|
Idx.push_back(ConstantUInt::get(Type::UIntTy, 0));
|
|
Value *NextFieldPtr = new GetElementPtrInst(JmpBuf, Idx, "NextField", II);
|
|
new StoreInst(OldEntry, NextFieldPtr, II);
|
|
new StoreInst(JmpBuf, JBListHead, II);
|
|
|
|
// Call setjmp, passing in the address of the jmpbuffer.
|
|
Idx[1] = ConstantUInt::get(Type::UIntTy, 1);
|
|
Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx, "TheJmpBuf", II);
|
|
Value *SJRet = new CallInst(SetJmpFn, JmpBufPtr, "sjret", II);
|
|
|
|
// Compare the return value to zero.
|
|
Value *IsNormal = BinaryOperator::create(Instruction::SetEQ, SJRet,
|
|
Constant::getNullValue(SJRet->getType()),
|
|
"notunwind", II);
|
|
// Create the receiver block if there is a critical edge to the normal
|
|
// destination.
|
|
SplitCriticalEdge(II, 0, this);
|
|
Instruction *InsertLoc = II->getNormalDest()->begin();
|
|
|
|
// Insert a normal call instruction on the normal execution path.
|
|
std::string Name = II->getName(); II->setName("");
|
|
Value *NewCall = new CallInst(II->getCalledValue(),
|
|
std::vector<Value*>(II->op_begin()+3,
|
|
II->op_end()), Name,
|
|
InsertLoc);
|
|
II->replaceAllUsesWith(NewCall);
|
|
|
|
// If we got this far, then no exception was thrown and we can pop our
|
|
// jmpbuf entry off.
|
|
new StoreInst(OldEntry, JBListHead, InsertLoc);
|
|
|
|
// Now we change the invoke into a branch instruction.
|
|
new BranchInst(II->getNormalDest(), II->getUnwindDest(), IsNormal, II);
|
|
|
|
// Remove the InvokeInst now.
|
|
BB->getInstList().erase(II);
|
|
++NumLowered; Changed = true;
|
|
|
|
} else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->getTerminator())) {
|
|
if (UnwindBlock == 0) {
|
|
// Create two new blocks, the unwind block and the terminate block. Add
|
|
// them at the end of the function because they are not hot.
|
|
UnwindBlock = new BasicBlock("unwind", &F);
|
|
TermBlock = new BasicBlock("unwinderror", &F);
|
|
|
|
// Insert return instructions. These really should be "barrier"s, as
|
|
// they are unreachable.
|
|
new ReturnInst(F.getReturnType() == Type::VoidTy ? 0 :
|
|
Constant::getNullValue(F.getReturnType()), UnwindBlock);
|
|
new ReturnInst(F.getReturnType() == Type::VoidTy ? 0 :
|
|
Constant::getNullValue(F.getReturnType()), TermBlock);
|
|
}
|
|
|
|
// Load the JBList, if it's null, then there was no catch!
|
|
LoadInst *Ptr = new LoadInst(JBListHead, "ehlist", UI);
|
|
Value *NotNull = BinaryOperator::create(Instruction::SetNE, Ptr,
|
|
Constant::getNullValue(Ptr->getType()),
|
|
"notnull", UI);
|
|
new BranchInst(UnwindBlock, TermBlock, NotNull, UI);
|
|
|
|
// Remember the loaded value so we can insert the PHI node as needed.
|
|
JBPtrs.push_back(Ptr);
|
|
|
|
// Remove the UnwindInst now.
|
|
BB->getInstList().erase(UI);
|
|
++NumLowered; Changed = true;
|
|
}
|
|
|
|
// If an unwind instruction was inserted, we need to set up the Unwind and
|
|
// term blocks.
|
|
if (UnwindBlock) {
|
|
// In the unwind block, we know that the pointer coming in on the JBPtrs
|
|
// list are non-null.
|
|
Instruction *RI = UnwindBlock->getTerminator();
|
|
|
|
Value *RecPtr;
|
|
if (JBPtrs.size() == 1)
|
|
RecPtr = JBPtrs[0];
|
|
else {
|
|
// If there is more than one unwind in this function, make a PHI node to
|
|
// merge in all of the loaded values.
|
|
PHINode *PN = new PHINode(JBPtrs[0]->getType(), "jbptrs", RI);
|
|
for (unsigned i = 0, e = JBPtrs.size(); i != e; ++i)
|
|
PN->addIncoming(JBPtrs[i], JBPtrs[i]->getParent());
|
|
RecPtr = PN;
|
|
}
|
|
|
|
// Now that we have a pointer to the whole record, remove the entry from the
|
|
// JBList.
|
|
std::vector<Value*> Idx;
|
|
Idx.push_back(Constant::getNullValue(Type::LongTy));
|
|
Idx.push_back(ConstantUInt::get(Type::UIntTy, 0));
|
|
Value *NextFieldPtr = new GetElementPtrInst(RecPtr, Idx, "NextField", RI);
|
|
Value *NextRec = new LoadInst(NextFieldPtr, "NextRecord", RI);
|
|
new StoreInst(NextRec, JBListHead, RI);
|
|
|
|
// Now that we popped the top of the JBList, get a pointer to the jmpbuf and
|
|
// longjmp.
|
|
Idx[1] = ConstantUInt::get(Type::UIntTy, 1);
|
|
Idx[0] = new GetElementPtrInst(RecPtr, Idx, "JmpBuf", RI);
|
|
Idx[1] = ConstantInt::get(Type::IntTy, 1);
|
|
new CallInst(LongJmpFn, Idx, "", RI);
|
|
|
|
// Now we set up the terminate block.
|
|
RI = TermBlock->getTerminator();
|
|
|
|
// Insert a new call to write(2, AbortMessage, AbortMessageLength);
|
|
writeAbortMessage(RI);
|
|
|
|
// Insert a call to abort()
|
|
new CallInst(AbortFn, std::vector<Value*>(), "", RI);
|
|
}
|
|
|
|
return Changed;
|
|
}
|
|
|
|
bool LowerInvoke::runOnFunction(Function &F) {
|
|
if (ExpensiveEHSupport)
|
|
return insertExpensiveEHSupport(F);
|
|
else
|
|
return insertCheapEHSupport(F);
|
|
}
|