diff options
| -rw-r--r-- | include/llvm/Transforms/Utils/Cloning.h | 25 | ||||
| -rw-r--r-- | lib/Transforms/IPO/InlineSimple.cpp | 13 | ||||
| -rw-r--r-- | lib/Transforms/Utils/CloneFunction.cpp | 19 |
3 files changed, 38 insertions, 19 deletions
diff --git a/include/llvm/Transforms/Utils/Cloning.h b/include/llvm/Transforms/Utils/Cloning.h index 7434a2ece8..a6cefc5589 100644 --- a/include/llvm/Transforms/Utils/Cloning.h +++ b/include/llvm/Transforms/Utils/Cloning.h @@ -12,6 +12,7 @@ #define LLVM_TRANSFORMS_UTIlS_CLONING_H #include <vector> +#include <map> class Module; class Function; class BasicBlock; @@ -19,6 +20,28 @@ class Value; class CallInst; class ReturnInst; +/// CloneModule - Return an exact copy of the specified module +/// +Module *CloneModule(Module *M); + +/// CloneFunction - Return a copy of the specified function, but without +/// embedding the function into another module. Also, any references specified +/// in the ValueMap are changed to refer to their mapped value instead of the +/// original one. If any of the arguments to the function are in the ValueMap, +/// the arguments are deleted from the resultant function. The ValueMap is +/// updated to include mappings from all of the instructions and basicblocks in +/// the function from their old to new values. +/// +Function *CloneFunction(const Function *F, + std::map<const Value*, Value*> &ValueMap); + +/// CloneFunction - Version of the function that doesn't need the ValueMap. +/// +inline Function *CloneFunction(const Function *F) { + std::map<const Value*, Value*> ValueMap; + return CloneFunction(F, ValueMap); +} + // Clone OldFunc into NewFunc, transforming the old arguments into references to // ArgMap values. Note that if NewFunc already has basic blocks, the ones // cloned into it will be added to the end of the function. This function fills @@ -26,7 +49,7 @@ class ReturnInst; // suffix to all values cloned. // void CloneFunctionInto(Function *NewFunc, const Function *OldFunc, - const std::vector<Value*> &ArgMap, + std::map<const Value*, Value*> &ValueMap, std::vector<ReturnInst*> &Returns, const char *NameSuffix = ""); diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index b4542ead3e..6dbab594e8 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -90,9 +90,14 @@ bool InlineFunction(CallInst *CI) { Function::iterator LastBlock = &OrigBB->getParent()->back(); // 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)); + std::map<const Value*, Value*> ValueMap; + assert((unsigned)std::distance(CalledFunc->abegin(), CalledFunc->aend()) == + CI->getNumOperands()-1 && "No varargs calls can be inlined yet!"); + + unsigned i = 1; + for (Function::const_aiterator I = CalledFunc->abegin(), E=CalledFunc->aend(); + I != E; ++I, ++i) + ValueMap[I] = CI->getOperand(i); // Since we are now done with the CallInst, we can delete it. delete CI; @@ -101,7 +106,7 @@ bool InlineFunction(CallInst *CI) { std::vector<ReturnInst*> Returns; // Do all of the hard part of cloning the callee into the caller... - CloneFunctionInto(OrigBB->getParent(), CalledFunc, ArgVector, Returns, ".i"); + CloneFunctionInto(OrigBB->getParent(), CalledFunc, ValueMap, Returns, ".i"); // Loop over all of the return instructions, turning them into unconditional // branches to the merge point now... diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp index 442ff03df3..36b3a7e701 100644 --- a/lib/Transforms/Utils/CloneFunction.cpp +++ b/lib/Transforms/Utils/CloneFunction.cpp @@ -37,25 +37,16 @@ static inline void RemapInstruction(Instruction *I, // ArgMap values. // void CloneFunctionInto(Function *NewFunc, const Function *OldFunc, - const std::vector<Value*> &ArgMap, + std::map<const Value*, Value*> &ValueMap, 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!"); - // 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. - // - std::map<const Value *, Value*> ValueMap; - - // Add all of the function arguments to the mapping... - unsigned i = 0; +#ifndef NDEBUG for (Function::const_aiterator I = OldFunc->abegin(), E = OldFunc->aend(); - I != E; ++I, ++i) - ValueMap[I] = ArgMap[i]; - + I != E; ++I) + assert(ValueMap.count(I) && "No mapping from source argument specified!"); +#endif // Loop over all of the basic blocks in the function, cloning them as // appropriate. Note that we save BE this way in order to handle cloning of |