Cloning.h revision 43ea505fb07e303721d92f2b2bdda6e601868523
1//===- Cloning.h - Clone various parts of LLVM programs ---------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines various functions that are used to clone chunks of LLVM 11// code for various purposes. This varies from copying whole modules into new 12// modules, to cloning functions with different arguments, to inlining 13// functions, to copying basic blocks to support loop unrolling or superblock 14// formation, etc. 15// 16//===----------------------------------------------------------------------===// 17 18#ifndef LLVM_TRANSFORMS_UTILS_CLONING_H 19#define LLVM_TRANSFORMS_UTILS_CLONING_H 20 21#include "llvm/ADT/DenseMap.h" 22 23namespace llvm { 24 25class Module; 26class Function; 27class Instruction; 28class Pass; 29class LPPassManager; 30class BasicBlock; 31class Value; 32class CallInst; 33class InvokeInst; 34class ReturnInst; 35class CallSite; 36class Trace; 37class CallGraph; 38class TargetData; 39class Loop; 40class LoopInfo; 41class AllocaInst; 42template <typename T> class SmallVectorImpl; 43 44/// CloneModule - Return an exact copy of the specified module 45/// 46Module *CloneModule(const Module *M); 47Module *CloneModule(const Module *M, DenseMap<const Value*, Value*> &ValueMap); 48 49/// ClonedCodeInfo - This struct can be used to capture information about code 50/// being cloned, while it is being cloned. 51struct ClonedCodeInfo { 52 /// ContainsCalls - This is set to true if the cloned code contains a normal 53 /// call instruction. 54 bool ContainsCalls; 55 56 /// ContainsUnwinds - This is set to true if the cloned code contains an 57 /// unwind instruction. 58 bool ContainsUnwinds; 59 60 /// ContainsDynamicAllocas - This is set to true if the cloned code contains 61 /// a 'dynamic' alloca. Dynamic allocas are allocas that are either not in 62 /// the entry block or they are in the entry block but are not a constant 63 /// size. 64 bool ContainsDynamicAllocas; 65 66 ClonedCodeInfo() { 67 ContainsCalls = false; 68 ContainsUnwinds = false; 69 ContainsDynamicAllocas = false; 70 } 71}; 72 73 74/// CloneBasicBlock - Return a copy of the specified basic block, but without 75/// embedding the block into a particular function. The block returned is an 76/// exact copy of the specified basic block, without any remapping having been 77/// performed. Because of this, this is only suitable for applications where 78/// the basic block will be inserted into the same function that it was cloned 79/// from (loop unrolling would use this, for example). 80/// 81/// Also, note that this function makes a direct copy of the basic block, and 82/// can thus produce illegal LLVM code. In particular, it will copy any PHI 83/// nodes from the original block, even though there are no predecessors for the 84/// newly cloned block (thus, phi nodes will have to be updated). Also, this 85/// block will branch to the old successors of the original block: these 86/// successors will have to have any PHI nodes updated to account for the new 87/// incoming edges. 88/// 89/// The correlation between instructions in the source and result basic blocks 90/// is recorded in the ValueMap map. 91/// 92/// If you have a particular suffix you'd like to use to add to any cloned 93/// names, specify it as the optional third parameter. 94/// 95/// If you would like the basic block to be auto-inserted into the end of a 96/// function, you can specify it as the optional fourth parameter. 97/// 98/// If you would like to collect additional information about the cloned 99/// function, you can specify a ClonedCodeInfo object with the optional fifth 100/// parameter. 101/// 102BasicBlock *CloneBasicBlock(const BasicBlock *BB, 103 DenseMap<const Value*, Value*> &ValueMap, 104 const char *NameSuffix = "", Function *F = 0, 105 ClonedCodeInfo *CodeInfo = 0); 106 107 108/// CloneLoop - Clone Loop. Clone dominator info for loop insiders. Populate 109/// ValueMap using old blocks to new blocks mapping. 110Loop *CloneLoop(Loop *L, LPPassManager *LPM, LoopInfo *LI, 111 DenseMap<const Value *, Value *> &ValueMap, Pass *P); 112 113/// CloneFunction - Return a copy of the specified function, but without 114/// embedding the function into another module. Also, any references specified 115/// in the ValueMap are changed to refer to their mapped value instead of the 116/// original one. If any of the arguments to the function are in the ValueMap, 117/// the arguments are deleted from the resultant function. The ValueMap is 118/// updated to include mappings from all of the instructions and basicblocks in 119/// the function from their old to new values. The final argument captures 120/// information about the cloned code if non-null. 121/// 122Function *CloneFunction(const Function *F, 123 DenseMap<const Value*, Value*> &ValueMap, 124 ClonedCodeInfo *CodeInfo = 0); 125 126/// CloneFunction - Version of the function that doesn't need the ValueMap. 127/// 128inline Function *CloneFunction(const Function *F, ClonedCodeInfo *CodeInfo = 0){ 129 DenseMap<const Value*, Value*> ValueMap; 130 return CloneFunction(F, ValueMap, CodeInfo); 131} 132 133/// Clone OldFunc into NewFunc, transforming the old arguments into references 134/// to ArgMap values. Note that if NewFunc already has basic blocks, the ones 135/// cloned into it will be added to the end of the function. This function 136/// fills in a list of return instructions, and can optionally append the 137/// specified suffix to all values cloned. 138/// 139void CloneFunctionInto(Function *NewFunc, const Function *OldFunc, 140 DenseMap<const Value*, Value*> &ValueMap, 141 SmallVectorImpl<ReturnInst*> &Returns, 142 const char *NameSuffix = "", 143 ClonedCodeInfo *CodeInfo = 0); 144 145/// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto, 146/// except that it does some simple constant prop and DCE on the fly. The 147/// effect of this is to copy significantly less code in cases where (for 148/// example) a function call with constant arguments is inlined, and those 149/// constant arguments cause a significant amount of code in the callee to be 150/// dead. Since this doesn't produce an exactly copy of the input, it can't be 151/// used for things like CloneFunction or CloneModule. 152void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc, 153 DenseMap<const Value*, Value*> &ValueMap, 154 SmallVectorImpl<ReturnInst*> &Returns, 155 const char *NameSuffix = "", 156 ClonedCodeInfo *CodeInfo = 0, 157 const TargetData *TD = 0, 158 Instruction *TheCall = 0); 159 160/// InlineFunction - This function inlines the called function into the basic 161/// block of the caller. This returns false if it is not possible to inline 162/// this call. The program is still in a well defined state if this occurs 163/// though. 164/// 165/// Note that this only does one level of inlining. For example, if the 166/// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now 167/// exists in the instruction stream. Similiarly this will inline a recursive 168/// function by one level. 169/// 170/// If a non-null callgraph pointer is provided, these functions update the 171/// CallGraph to represent the program after inlining. 172/// 173/// If StaticAllocas is non-null, InlineFunction populates it with all of the 174/// static allocas that it inlines into the caller. 175/// 176bool InlineFunction(CallInst *C, CallGraph *CG = 0, const TargetData *TD = 0, 177 SmallVectorImpl<AllocaInst*> *StaticAllocas = 0); 178bool InlineFunction(InvokeInst *II, CallGraph *CG = 0, const TargetData *TD = 0, 179 SmallVectorImpl<AllocaInst*> *StaticAllocas = 0); 180bool InlineFunction(CallSite CS, CallGraph *CG = 0, const TargetData *TD = 0, 181 SmallVectorImpl<AllocaInst*> *StaticAllocas = 0); 182 183} // End llvm namespace 184 185#endif 186