forked from OSchip/llvm-project
87 lines
3.0 KiB
C++
87 lines
3.0 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 gives them 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().
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/iTerminators.h"
|
|
#include "llvm/iOther.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Type.h"
|
|
#include "llvm/Constant.h"
|
|
#include "Support/Statistic.h"
|
|
|
|
namespace llvm {
|
|
|
|
namespace {
|
|
Statistic<> NumLowered("lowerinvoke", "Number of invoke & unwinds replaced");
|
|
|
|
class LowerInvoke : public FunctionPass {
|
|
Function *AbortFn;
|
|
public:
|
|
bool doInitialization(Module &M);
|
|
bool runOnFunction(Function &F);
|
|
};
|
|
|
|
RegisterOpt<LowerInvoke>
|
|
X("lowerinvoke", "Lower invoke and unwind, for unwindless code generators");
|
|
}
|
|
|
|
// Public Interface To the LowerInvoke pass.
|
|
FunctionPass *createLowerInvokePass() { return new LowerInvoke(); }
|
|
|
|
// doInitialization - Make sure that there is a prototype for abort in the
|
|
// current module.
|
|
bool LowerInvoke::doInitialization(Module &M) {
|
|
AbortFn = M.getOrInsertFunction("abort", Type::VoidTy, 0);
|
|
return true;
|
|
}
|
|
|
|
bool LowerInvoke::runOnFunction(Function &F) {
|
|
bool Changed = false;
|
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(I->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 the invoke instruction now.
|
|
I->getInstList().erase(II);
|
|
|
|
++NumLowered; Changed = true;
|
|
} else if (UnwindInst *UI = dyn_cast<UnwindInst>(I->getTerminator())) {
|
|
// Insert a call to abort()
|
|
new CallInst(AbortFn, std::vector<Value*>(), "", UI);
|
|
|
|
// Insert a return instruction.
|
|
new ReturnInst(F.getReturnType() == Type::VoidTy ? 0 :
|
|
Constant::getNullValue(F.getReturnType()), UI);
|
|
|
|
// Remove the unwind instruction now.
|
|
I->getInstList().erase(UI);
|
|
|
|
++NumLowered; Changed = true;
|
|
}
|
|
return Changed;
|
|
}
|
|
|
|
} // End llvm namespace
|