#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/Analysis/CallGraph.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/CallSite.h"
using namespace llvm;
-bool llvm::InlineFunction(CallInst *CI, CallGraph *CG) {
- return InlineFunction(CallSite(CI), CG);
+bool llvm::InlineFunction(CallInst *CI, CallGraph *CG, const TargetData *TD) {
+ return InlineFunction(CallSite(CI), CG, TD);
}
-bool llvm::InlineFunction(InvokeInst *II, CallGraph *CG) {
- return InlineFunction(CallSite(II), CG);
+bool llvm::InlineFunction(InvokeInst *II, CallGraph *CG, const TargetData *TD) {
+ return InlineFunction(CallSite(II), CG, TD);
}
/// HandleInlinedInvoke - If we inlined an invoke site, we need to convert calls
if (!isa<CallInst>(I)) continue;
CallInst *CI = cast<CallInst>(I);
- // If this is an intrinsic function call, don't convert it to an
- // invoke.
- if (CI->getCalledFunction() &&
- CI->getCalledFunction()->getIntrinsicID())
+ // If this is an intrinsic function call or an inline asm, don't
+ // convert it to an invoke.
+ if ((CI->getCalledFunction() &&
+ CI->getCalledFunction()->getIntrinsicID()) ||
+ isa<InlineAsm>(CI->getCalledValue()))
continue;
// Convert this function call into an invoke instruction.
// Next, create the new invoke instruction, inserting it at the end
// of the old basic block.
+ SmallVector<Value*, 8> InvokeArgs(CI->op_begin()+1, CI->op_end());
InvokeInst *II =
new InvokeInst(CI->getCalledValue(), Split, InvokeDest,
- std::vector<Value*>(CI->op_begin()+1, CI->op_end()),
+ &InvokeArgs[0], InvokeArgs.size(),
CI->getName(), BB->getTerminator());
II->setCallingConv(CI->getCallingConv());
static void UpdateCallGraphAfterInlining(const Function *Caller,
const Function *Callee,
Function::iterator FirstNewBlock,
- std::map<const Value*, Value*> &ValueMap,
+ DenseMap<const Value*, Value*> &ValueMap,
CallGraph &CG) {
// Update the call graph by deleting the edge from Callee to Caller
CallGraphNode *CalleeNode = CG[Callee];
E = CalleeNode->end(); I != E; ++I) {
const Instruction *OrigCall = I->first.getInstruction();
- std::map<const Value*, Value*>::iterator VMI = ValueMap.find(OrigCall);
+ DenseMap<const Value*, Value*>::iterator VMI = ValueMap.find(OrigCall);
// Only copy the edge if the call was inlined!
if (VMI != ValueMap.end() && VMI->second) {
// If the call was inlined, but then constant folded, there is no edge to
// exists in the instruction stream. Similiarly this will inline a recursive
// function by one level.
//
-bool llvm::InlineFunction(CallSite CS, CallGraph *CG) {
+bool llvm::InlineFunction(CallSite CS, CallGraph *CG, const TargetData *TD) {
Instruction *TheCall = CS.getInstruction();
assert(TheCall->getParent() && TheCall->getParent()->getParent() &&
"Instruction not in function!");
const Function *CalledFunc = CS.getCalledFunction();
if (CalledFunc == 0 || // Can't inline external function or indirect
- CalledFunc->isExternal() || // call, or call to a vararg function!
+ CalledFunc->isDeclaration() || // call, or call to a vararg function!
CalledFunc->getFunctionType()->isVarArg()) return false;
Function::iterator FirstNewBlock;
{ // Scope to destroy ValueMap after cloning.
- std::map<const Value*, Value*> ValueMap;
+ DenseMap<const Value*, Value*> ValueMap;
// Calculate the vector of arguments to pass into the function cloner, which
// matches up the formal to the actual argument values.
// (which can happen, e.g., because an argument was constant), but we'll be
// happy with whatever the cloner can do.
CloneAndPruneFunctionInto(Caller, CalledFunc, ValueMap, Returns, ".i",
- &InlinedFunctionInfo);
+ &InlinedFunctionInfo, TD);
// Remember the first block that is newly cloned over.
FirstNewBlock = LastBlock; ++FirstNewBlock;
BasicBlock::iterator InsertPoint = Caller->begin()->begin();
for (BasicBlock::iterator I = FirstNewBlock->begin(),
E = FirstNewBlock->end(); I != E; )
- if (AllocaInst *AI = dyn_cast<AllocaInst>(I++))
+ if (AllocaInst *AI = dyn_cast<AllocaInst>(I++)) {
+ // If the alloca is now dead, remove it. This often occurs due to code
+ // specialization.
+ if (AI->use_empty()) {
+ AI->eraseFromParent();
+ continue;
+ }
+
if (isa<Constant>(AI->getArraySize())) {
// Scan for the block of allocas that we can move over, and move them
// all at once.
++I;
// Transfer all of the allocas over in a block. Using splice means
- // that they instructions aren't removed from the symbol table, then
+ // that the instructions aren't removed from the symbol table, then
// reinserted.
- Caller->front().getInstList().splice(InsertPoint,
- FirstNewBlock->getInstList(),
- AI, I);
+ Caller->getEntryBlock().getInstList().splice(
+ InsertPoint,
+ FirstNewBlock->getInstList(),
+ AI, I);
}
+ }
}
// If the inlined code contained dynamic alloca instructions, wrap the inlined
// code with llvm.stacksave/llvm.stackrestore intrinsics.
if (InlinedFunctionInfo.ContainsDynamicAllocas) {
Module *M = Caller->getParent();
- const Type *SBytePtr = PointerType::get(Type::SByteTy);
+ const Type *BytePtr = PointerType::get(Type::Int8Ty);
// Get the two intrinsics we care about.
- Function *StackSave, *StackRestore;
- StackSave = M->getOrInsertFunction("llvm.stacksave", SBytePtr, NULL);
+ Constant *StackSave, *StackRestore;
+ StackSave = M->getOrInsertFunction("llvm.stacksave", BytePtr, NULL);
StackRestore = M->getOrInsertFunction("llvm.stackrestore", Type::VoidTy,
- SBytePtr, NULL);
+ BytePtr, NULL);
// If we are preserving the callgraph, add edges to the stacksave/restore
// functions for the calls we insert.
- CallGraphNode *StackSaveCGN, *StackRestoreCGN, *CallerNode;
+ CallGraphNode *StackSaveCGN = 0, *StackRestoreCGN = 0, *CallerNode = 0;
if (CG) {
- StackSaveCGN = CG->getOrInsertFunction(StackSave);
- StackRestoreCGN = CG->getOrInsertFunction(StackRestore);
+ // We know that StackSave/StackRestore are Function*'s, because they are
+ // intrinsics which must have the right types.
+ StackSaveCGN = CG->getOrInsertFunction(cast<Function>(StackSave));
+ StackRestoreCGN = CG->getOrInsertFunction(cast<Function>(StackRestore));
CallerNode = (*CG)[Caller];
}
projects / oota-llvm.git / blobdiff