forked from OSchip/llvm-project
Rework inline pass to use cloning infrastructure to do the dirty work
llvm-svn: 4766
This commit is contained in:
parent
891bbab848
commit
b1120055b9
|
@ -32,27 +32,6 @@
|
|||
static Statistic<> NumInlined("inline", "Number of functions inlined");
|
||||
using std::cerr;
|
||||
|
||||
// RemapInstruction - Convert the instruction operands from referencing the
|
||||
// current values into those specified by ValueMap.
|
||||
//
|
||||
static inline void RemapInstruction(Instruction *I,
|
||||
std::map<const Value *, Value*> &ValueMap) {
|
||||
|
||||
for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) {
|
||||
const Value *Op = I->getOperand(op);
|
||||
Value *V = ValueMap[Op];
|
||||
if (!V && (isa<GlobalValue>(Op) || isa<Constant>(Op)))
|
||||
continue; // Globals and constants don't get relocated
|
||||
|
||||
if (!V) {
|
||||
cerr << "Val = \n" << Op << "Addr = " << (void*)Op;
|
||||
cerr << "\nInst = " << I;
|
||||
}
|
||||
assert(V && "Referenced value not in value map!");
|
||||
I->setOperand(op, V);
|
||||
}
|
||||
}
|
||||
|
||||
// InlineFunction - This function forcibly inlines the called function into the
|
||||
// basic block of the caller. This returns false if it is not possible to
|
||||
// inline this call. The program is still in a well defined state if this
|
||||
|
@ -92,7 +71,7 @@ bool InlineFunction(CallInst *CI) {
|
|||
// function.
|
||||
//
|
||||
PHINode *PHI = 0;
|
||||
if (CalledFunc->getReturnType() != Type::VoidTy) {
|
||||
if (!CI->use_empty()) {
|
||||
// The PHI node should go at the front of the new basic block to merge all
|
||||
// possible incoming values.
|
||||
//
|
||||
|
@ -105,103 +84,53 @@ bool InlineFunction(CallInst *CI) {
|
|||
CI->replaceAllUsesWith(PHI);
|
||||
}
|
||||
|
||||
// Keep a mapping between the original function's values and the new
|
||||
// duplicated code's values. This includes all of: Function arguments,
|
||||
// instruction values, constant pool entries, and basic blocks.
|
||||
// Get a pointer to the last basic block in the function, which will have the
|
||||
// new function inlined after it.
|
||||
//
|
||||
std::map<const Value *, Value*> ValueMap;
|
||||
Function::iterator LastBlock = &OrigBB->getParent()->back();
|
||||
|
||||
// Add the function arguments to the mapping: (start counting at 1 to skip the
|
||||
// function reference itself)
|
||||
//
|
||||
Function::const_aiterator PTI = CalledFunc->abegin();
|
||||
for (unsigned a = 1, E = CI->getNumOperands(); a != E; ++a, ++PTI)
|
||||
ValueMap[PTI] = CI->getOperand(a);
|
||||
// Calculate the vector of arguments to pass into the function cloner...
|
||||
std::vector<Value*> ArgVector;
|
||||
for (unsigned i = 1, e = CI->getNumOperands(); i != e; ++i)
|
||||
ArgVector.push_back(CI->getOperand(i));
|
||||
|
||||
ValueMap[NewBB] = NewBB; // Returns get converted to reference NewBB
|
||||
// Since we are now done with the CallInst, we can delete it.
|
||||
delete CI;
|
||||
|
||||
// Loop over all of the basic blocks in the function, inlining them as
|
||||
// appropriate. Keep track of the first basic block of the function...
|
||||
//
|
||||
for (Function::const_iterator BB = CalledFunc->begin();
|
||||
BB != CalledFunc->end(); ++BB) {
|
||||
assert(BB->getTerminator() && "BasicBlock doesn't have terminator!?!?");
|
||||
// Make a vector to capture the return instructions in the cloned function...
|
||||
std::vector<ReturnInst*> Returns;
|
||||
|
||||
// Create a new basic block to copy instructions into!
|
||||
BasicBlock *IBB = new BasicBlock("", NewBB->getParent());
|
||||
if (BB->hasName()) IBB->setName(BB->getName()+".i"); // .i = inlined once
|
||||
// Do all of the hard part of cloning the callee into the caller...
|
||||
CloneFunctionInto(OrigBB->getParent(), CalledFunc, ArgVector, Returns, ".i");
|
||||
|
||||
ValueMap[BB] = IBB; // Add basic block mapping.
|
||||
// Loop over all of the return instructions, turning them into unconditional
|
||||
// branches to the merge point now...
|
||||
for (unsigned i = 0, e = Returns.size(); i != e; ++i) {
|
||||
ReturnInst *RI = Returns[i];
|
||||
BasicBlock *BB = RI->getParent();
|
||||
|
||||
// Make sure to capture the mapping that a return will use...
|
||||
// TODO: This assumes that the RET is returning a value computed in the same
|
||||
// basic block as the return was issued from!
|
||||
//
|
||||
const TerminatorInst *TI = BB->getTerminator();
|
||||
|
||||
// Loop over all instructions copying them over...
|
||||
Instruction *NewInst;
|
||||
for (BasicBlock::const_iterator II = BB->begin();
|
||||
II != --BB->end(); ++II) {
|
||||
IBB->getInstList().push_back((NewInst = II->clone()));
|
||||
ValueMap[II] = NewInst; // Add instruction map to value.
|
||||
if (II->hasName())
|
||||
NewInst->setName(II->getName()+".i"); // .i = inlined once
|
||||
}
|
||||
|
||||
// Copy over the terminator now...
|
||||
switch (TI->getOpcode()) {
|
||||
case Instruction::Ret: {
|
||||
const ReturnInst *RI = cast<ReturnInst>(TI);
|
||||
// Add a branch to the merge point where the PHI node would live...
|
||||
new BranchInst(NewBB, RI);
|
||||
|
||||
if (PHI) { // The PHI node should include this value!
|
||||
assert(RI->getReturnValue() && "Ret should have value!");
|
||||
assert(RI->getReturnValue()->getType() == PHI->getType() &&
|
||||
"Ret value not consistent in function!");
|
||||
PHI->addIncoming((Value*)RI->getReturnValue(),
|
||||
(BasicBlock*)cast<BasicBlock>(&*BB));
|
||||
PHI->addIncoming(RI->getReturnValue(), BB);
|
||||
}
|
||||
|
||||
// Add a branch to the code that was after the original Call.
|
||||
IBB->getInstList().push_back(new BranchInst(NewBB));
|
||||
break;
|
||||
// Delete the return instruction now
|
||||
BB->getInstList().erase(RI);
|
||||
}
|
||||
case Instruction::Br:
|
||||
IBB->getInstList().push_back(TI->clone());
|
||||
break;
|
||||
|
||||
default:
|
||||
cerr << "FunctionInlining: Don't know how to handle terminator: " << TI;
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Loop over all of the instructions in the function, fixing up operand
|
||||
// references as we go. This uses ValueMap to do all the hard work.
|
||||
//
|
||||
for (Function::const_iterator BB = CalledFunc->begin();
|
||||
BB != CalledFunc->end(); ++BB) {
|
||||
BasicBlock *NBB = (BasicBlock*)ValueMap[BB];
|
||||
|
||||
// Loop over all instructions, fixing each one as we find it...
|
||||
//
|
||||
for (BasicBlock::iterator II = NBB->begin(); II != NBB->end(); ++II)
|
||||
RemapInstruction(II, ValueMap);
|
||||
}
|
||||
|
||||
if (PHI) {
|
||||
RemapInstruction(PHI, ValueMap); // Fix the PHI node also...
|
||||
|
||||
// Check to see if the PHI node only has one argument. This is a common
|
||||
// case resulting from there only being a single return instruction in the
|
||||
// function call. Because this is so common, eliminate the PHI node.
|
||||
//
|
||||
if (PHI->getNumIncomingValues() == 1) {
|
||||
if (PHI && PHI->getNumIncomingValues() == 1) {
|
||||
PHI->replaceAllUsesWith(PHI->getIncomingValue(0));
|
||||
PHI->getParent()->getInstList().erase(PHI);
|
||||
}
|
||||
}
|
||||
|
||||
// Change the branch that used to go to NewBB to branch to the first basic
|
||||
// block of the inlined function.
|
||||
|
@ -209,10 +138,7 @@ bool InlineFunction(CallInst *CI) {
|
|||
TerminatorInst *Br = OrigBB->getTerminator();
|
||||
assert(Br && Br->getOpcode() == Instruction::Br &&
|
||||
"splitBasicBlock broken!");
|
||||
Br->setOperand(0, ValueMap[&CalledFunc->front()]);
|
||||
|
||||
// Since we are now done with the CallInst, we can finally delete it.
|
||||
delete CI;
|
||||
Br->setOperand(0, ++LastBlock);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
@ -4,6 +4,7 @@
|
|||
// FIXME: document
|
||||
|
||||
#include "llvm/Transforms/Utils/Cloning.h"
|
||||
#include "llvm/iTerminators.h"
|
||||
#include "llvm/Function.h"
|
||||
#include <map>
|
||||
|
||||
|
@ -35,9 +36,10 @@ static inline void RemapInstruction(Instruction *I,
|
|||
// ArgMap values.
|
||||
//
|
||||
void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
|
||||
const std::vector<Value*> &ArgMap) {
|
||||
assert(OldFunc->aempty() || !NewFunc->aempty() &&
|
||||
"Synthesization of arguments is not implemented yet!");
|
||||
const std::vector<Value*> &ArgMap,
|
||||
std::vector<ReturnInst*> &Returns,
|
||||
const char *NameSuffix) {
|
||||
assert(NameSuffix && "NameSuffix cannot be null!");
|
||||
assert(OldFunc->asize() == ArgMap.size() &&
|
||||
"Improper number of argument values to map specified!");
|
||||
|
||||
|
@ -55,25 +57,30 @@ void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
|
|||
|
||||
|
||||
// Loop over all of the basic blocks in the function, cloning them as
|
||||
// appropriate.
|
||||
// appropriate. Note that we save BE this way in order to handle cloning of
|
||||
// recursive functions into themselves.
|
||||
//
|
||||
for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end();
|
||||
BI != BE; ++BI) {
|
||||
const BasicBlock &BB = *BI;
|
||||
assert(BB.getTerminator() && "BasicBlock doesn't have terminator!?!?");
|
||||
|
||||
// Create a new basic block to copy instructions into!
|
||||
BasicBlock *CBB = new BasicBlock(BB.getName(), NewFunc);
|
||||
BasicBlock *CBB = new BasicBlock("", NewFunc);
|
||||
if (BB.hasName()) CBB->setName(BB.getName()+NameSuffix);
|
||||
ValueMap[&BB] = CBB; // Add basic block mapping.
|
||||
|
||||
// Loop over all instructions copying them over...
|
||||
for (BasicBlock::const_iterator II = BB.begin(), IE = BB.end();
|
||||
II != IE; ++II) {
|
||||
Instruction *NewInst = II->clone();
|
||||
NewInst->setName(II->getName()); // Name is not cloned...
|
||||
if (II->hasName())
|
||||
NewInst->setName(II->getName()+NameSuffix); // Name is not cloned...
|
||||
CBB->getInstList().push_back(NewInst);
|
||||
ValueMap[II] = NewInst; // Add instruction map to value.
|
||||
}
|
||||
|
||||
if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator()))
|
||||
Returns.push_back(RI);
|
||||
}
|
||||
|
||||
// Loop over all of the instructions in the function, fixing up operand
|
||||
|
|
Loading…
Reference in New Issue