CloneFunction.cpp revision a33ceaa2d46f6bf50c979e28581d9e4941b45d44
1//===- CloneFunction.cpp - Clone a function into another function ---------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the CloneFunctionInto interface, which is used as the 11// low-level function cloner. This is used by the CloneFunction and function 12// inliner to do the dirty work of copying the body of a function around. 13// 14//===----------------------------------------------------------------------===// 15 16#include "llvm/Transforms/Utils/Cloning.h" 17#include "llvm/iTerminators.h" 18#include "llvm/DerivedTypes.h" 19#include "llvm/Function.h" 20#include "ValueMapper.h" 21using namespace llvm; 22 23// RemapInstruction - Convert the instruction operands from referencing the 24// current values into those specified by ValueMap. 25// 26static inline void RemapInstruction(Instruction *I, 27 std::map<const Value *, Value*> &ValueMap) { 28 for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) { 29 const Value *Op = I->getOperand(op); 30 Value *V = MapValue(Op, ValueMap); 31#ifndef NDEBUG 32 if (!V) { 33 std::cerr << "Val = \n" << Op << "Addr = " << (void*)Op; 34 std::cerr << "\nInst = " << I; 35 } 36#endif 37 assert(V && "Referenced value not in value map!"); 38 I->setOperand(op, V); 39 } 40} 41 42// CloneBasicBlock - See comments in Cloning.h 43BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB, 44 std::map<const Value*, Value*> &ValueMap, 45 const char *NameSuffix, Function *F) { 46 BasicBlock *NewBB = new BasicBlock("", F); 47 if (BB->hasName()) NewBB->setName(BB->getName()+NameSuffix); 48 49 // Loop over all instructions copying them over... 50 for (BasicBlock::const_iterator II = BB->begin(), IE = BB->end(); 51 II != IE; ++II) { 52 Instruction *NewInst = II->clone(); 53 if (II->hasName()) 54 NewInst->setName(II->getName()+NameSuffix); 55 NewBB->getInstList().push_back(NewInst); 56 ValueMap[II] = NewInst; // Add instruction map to value. 57 } 58 return NewBB; 59} 60 61// Clone OldFunc into NewFunc, transforming the old arguments into references to 62// ArgMap values. 63// 64void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, 65 std::map<const Value*, Value*> &ValueMap, 66 std::vector<ReturnInst*> &Returns, 67 const char *NameSuffix) { 68 assert(NameSuffix && "NameSuffix cannot be null!"); 69 70#ifndef NDEBUG 71 for (Function::const_aiterator I = OldFunc->abegin(), E = OldFunc->aend(); 72 I != E; ++I) 73 assert(ValueMap.count(I) && "No mapping from source argument specified!"); 74#endif 75 76 // Loop over all of the basic blocks in the function, cloning them as 77 // appropriate. Note that we save BE this way in order to handle cloning of 78 // recursive functions into themselves. 79 // 80 for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end(); 81 BI != BE; ++BI) { 82 const BasicBlock &BB = *BI; 83 84 // Create a new basic block and copy instructions into it! 85 BasicBlock *CBB = CloneBasicBlock(&BB, ValueMap, NameSuffix, NewFunc); 86 ValueMap[&BB] = CBB; // Add basic block mapping. 87 88 if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator())) 89 Returns.push_back(RI); 90 } 91 92 // Loop over all of the instructions in the function, fixing up operand 93 // references as we go. This uses ValueMap to do all the hard work. 94 // 95 for (Function::iterator BB = cast<BasicBlock>(ValueMap[OldFunc->begin()]), 96 BE = NewFunc->end(); BB != BE; ++BB) 97 // Loop over all instructions, fixing each one as we find it... 98 for (BasicBlock::iterator II = BB->begin(); II != BB->end(); ++II) 99 RemapInstruction(II, ValueMap); 100} 101 102/// CloneFunction - Return a copy of the specified function, but without 103/// embedding the function into another module. Also, any references specified 104/// in the ValueMap are changed to refer to their mapped value instead of the 105/// original one. If any of the arguments to the function are in the ValueMap, 106/// the arguments are deleted from the resultant function. The ValueMap is 107/// updated to include mappings from all of the instructions and basicblocks in 108/// the function from their old to new values. 109/// 110Function *llvm::CloneFunction(const Function *F, 111 std::map<const Value*, Value*> &ValueMap) { 112 std::vector<const Type*> ArgTypes; 113 114 // The user might be deleting arguments to the function by specifying them in 115 // the ValueMap. If so, we need to not add the arguments to the arg ty vector 116 // 117 for (Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 118 if (ValueMap.count(I) == 0) // Haven't mapped the argument to anything yet? 119 ArgTypes.push_back(I->getType()); 120 121 // Create a new function type... 122 FunctionType *FTy = FunctionType::get(F->getFunctionType()->getReturnType(), 123 ArgTypes, F->getFunctionType()->isVarArg()); 124 125 // Create the new function... 126 Function *NewF = new Function(FTy, F->getLinkage(), F->getName()); 127 128 // Loop over the arguments, copying the names of the mapped arguments over... 129 Function::aiterator DestI = NewF->abegin(); 130 for (Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 131 if (ValueMap.count(I) == 0) { // Is this argument preserved? 132 DestI->setName(I->getName()); // Copy the name over... 133 ValueMap[I] = DestI++; // Add mapping to ValueMap 134 } 135 136 std::vector<ReturnInst*> Returns; // Ignore returns cloned... 137 CloneFunctionInto(NewF, F, ValueMap, Returns); 138 return NewF; 139} 140 141