#define LLVM_TRANSFORMS_UTIlS_CLONING_H
#include <vector>
+#include <map>
class Module;
class Function;
class BasicBlock;
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
// 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 = "");
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;
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...
// 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