Minor changes to cloning interface

llvm-svn: 4770

llvm/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 = "");
 

llvm/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...

llvm/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