#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 call cannot unwind, don't convert it to an invoke.
+ if (CI->isNoUnwind())
continue;
-
+
// Convert this function call into an invoke instruction.
// First, split the basic block.
BasicBlock *Split = BB->splitBasicBlock(CI, CI->getName()+".noexc");
// 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.begin(), InvokeArgs.end(),
CI->getName(), BB->getTerminator());
II->setCallingConv(CI->getCallingConv());
+ II->setParamAttrs(CI->getParamAttrs());
// Make sure that anything using the call now uses the invoke!
CI->replaceAllUsesWith(II);
InvokeDest->removePredecessor(II->getParent());
}
-/// UpdateCallGraphAfterInlining - Once we have finished inlining a call from
-/// caller to callee, update the specified callgraph to reflect the changes we
-/// made.
-static void UpdateCallGraphAfterInlining(const Function *Caller,
+/// UpdateCallGraphAfterInlining - Once we have cloned code over from a callee
+/// into the caller, update the specified callgraph to reflect the changes we
+/// made. Note that it's possible that not all code was copied over, so only
+/// some edges of the callgraph will be remain.
+static void UpdateCallGraphAfterInlining(const Function *Caller,
const Function *Callee,
+ Function::iterator FirstNewBlock,
+ DenseMap<const Value*, Value*> &ValueMap,
CallGraph &CG) {
// Update the call graph by deleting the edge from Callee to Caller
CallGraphNode *CalleeNode = CG[Callee];
CallGraphNode *CallerNode = CG[Caller];
CallerNode->removeCallEdgeTo(CalleeNode);
- // Since we inlined all uninlined call sites in the callee into the caller,
+ // Since we inlined some uninlined call sites in the callee into the caller,
// add edges from the caller to all of the callees of the callee.
for (CallGraphNode::iterator I = CalleeNode->begin(),
- E = CalleeNode->end(); I != E; ++I)
- CallerNode->addCalledFunction(*I);
+ E = CalleeNode->end(); I != E; ++I) {
+ const Instruction *OrigCall = I->first.getInstruction();
+
+ 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
+ // add. Check for this case.
+ if (Instruction *NewCall = dyn_cast<Instruction>(VMI->second))
+ CallerNode->addCalledFunction(CallSite::get(NewCall), I->second);
+ }
+ }
}
// 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.
std::vector<ReturnInst*> Returns;
ClonedCodeInfo InlinedFunctionInfo;
+ Function::iterator FirstNewBlock;
+
{ // Scope to destroy ValueMap after cloning.
- // Calculate the vector of arguments to pass into the function cloner...
- 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.
assert(std::distance(CalledFunc->arg_begin(), CalledFunc->arg_end()) ==
std::distance(CS.arg_begin(), CS.arg_end()) &&
"No varargs calls can be inlined!");
-
CallSite::arg_iterator AI = CS.arg_begin();
for (Function::const_arg_iterator I = CalledFunc->arg_begin(),
E = CalledFunc->arg_end(); I != E; ++I, ++AI)
ValueMap[I] = *AI;
- // Clone the entire body of the callee into the caller.
- CloneFunctionInto(Caller, CalledFunc, ValueMap, Returns, ".i",
- &InlinedFunctionInfo);
+ // We want the inliner to prune the code as it copies. We would LOVE to
+ // have no dead or constant instructions leftover after inlining occurs
+ // (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, TD);
+
+ // Remember the first block that is newly cloned over.
+ FirstNewBlock = LastBlock; ++FirstNewBlock;
+
+ // Update the callgraph if requested.
+ if (CG)
+ UpdateCallGraphAfterInlining(Caller, CalledFunc, FirstNewBlock, ValueMap,
+ *CG);
}
-
- // Remember the first block that is newly cloned over.
- Function::iterator FirstNewBlock = LastBlock; ++FirstNewBlock;
-
+
// If there are any alloca instructions in the block that used to be the entry
// block for the callee, move them to the entry block of the caller. First
// calculate which instruction they should be inserted before. We insert the
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 = 0, *StackRestoreCGN = 0, *CallerNode = 0;
+ if (CG) {
+ // 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];
+ }
+
// Insert the llvm.stacksave.
- Value *SavedPtr = new CallInst(StackSave, "savedstack",
- FirstNewBlock->begin());
-
+ CallInst *SavedPtr = new CallInst(StackSave, "savedstack",
+ FirstNewBlock->begin());
+ if (CG) CallerNode->addCalledFunction(SavedPtr, StackSaveCGN);
+
// Insert a call to llvm.stackrestore before any return instructions in the
// inlined function.
- for (unsigned i = 0, e = Returns.size(); i != e; ++i)
- new CallInst(StackRestore, SavedPtr, "", Returns[i]);
+ for (unsigned i = 0, e = Returns.size(); i != e; ++i) {
+ CallInst *CI = new CallInst(StackRestore, SavedPtr, "", Returns[i]);
+ if (CG) CallerNode->addCalledFunction(CI, StackRestoreCGN);
+ }
// Count the number of StackRestore calls we insert.
unsigned NumStackRestores = Returns.size();
++NumStackRestores;
}
}
-
- // If we are supposed to update the callgraph, do so now.
- if (CG) {
- CallGraphNode *StackSaveCGN = CG->getOrInsertFunction(StackSave);
- CallGraphNode *StackRestoreCGN = CG->getOrInsertFunction(StackRestore);
- CallGraphNode *CallerNode = (*CG)[Caller];
-
- // 'Caller' now calls llvm.stacksave one more time.
- CallerNode->addCalledFunction(StackSaveCGN);
-
- // 'Caller' now calls llvm.stackrestore the appropriate number of times.
- for (unsigned i = 0; i != NumStackRestores; ++i)
- CallerNode->addCalledFunction(StackRestoreCGN);
- }
}
// If we are inlining tail call instruction through a call site that isn't
// Since we are now done with the return instruction, delete it also.
Returns[0]->getParent()->getInstList().erase(Returns[0]);
- // Update the callgraph if requested.
- if (CG) UpdateCallGraphAfterInlining(Caller, CalledFunc, *CG);
-
// We are now done with the inlining.
return true;
}
// Now we can remove the CalleeEntry block, which is now empty.
Caller->getBasicBlockList().erase(CalleeEntry);
- // Update the callgraph if requested.
- if (CG) UpdateCallGraphAfterInlining(Caller, CalledFunc, *CG);
-
return true;
}
projects / oota-llvm.git / blobdiff