Teach inline function how to update the callgraph when it makes changes.

[oota-llvm.git] / include / llvm / Transforms / Utils / Cloning.h

diff --git a/include/llvm/Transforms/Utils/Cloning.h b/include/llvm/Transforms/Utils/Cloning.h
index 49b5e3304238d46048557481b4cc748242ed5eb9..f721ea900d7e9b2d0be2fb52e398e4c2f5da23c1 100644 (file)
--- a/include/llvm/Transforms/Utils/Cloning.h
+++ b/include/llvm/Transforms/Utils/Cloning.h
@@ -32,11 +32,37 @@ class InvokeInst;
 class ReturnInst;
 class CallSite;
 class Trace;
+class CallGraph;
 
 /// CloneModule - Return an exact copy of the specified module
 ///
 Module *CloneModule(const Module *M);
 
+/// ClonedCodeInfo - This struct can be used to capture information about code
+/// being cloned, while it is being cloned.
+struct ClonedCodeInfo {
+  /// ContainsCalls - This is set to true if the cloned code contains a normal
+  /// call instruction.
+  bool ContainsCalls;
+  
+  /// ContainsUnwinds - This is set to true if the cloned code contains an
+  /// unwind instruction.
+  bool ContainsUnwinds;
+  
+  /// ContainsDynamicAllocas - This is set to true if the cloned code contains
+  /// a 'dynamic' alloca.  Dynamic allocas are allocas that are either not in
+  /// the entry block or they are in the entry block but are not a constant
+  /// size.
+  bool ContainsDynamicAllocas;
+  
+  ClonedCodeInfo() {
+    ContainsCalls = false;
+    ContainsUnwinds = false;
+    ContainsDynamicAllocas = false;
+  }
+};
+
+
 /// CloneBasicBlock - Return a copy of the specified basic block, but without
 /// embedding the block into a particular function.  The block returned is an
 /// exact copy of the specified basic block, without any remapping having been
@@ -61,9 +87,14 @@ Module *CloneModule(const Module *M);
 /// If you would like the basic block to be auto-inserted into the end of a
 /// function, you can specify it as the optional fourth parameter.
 ///
+/// If you would like to collect additional information about the cloned
+/// function, you can specify a ClonedCodeInfo object with the optional fifth
+/// parameter.
+///
 BasicBlock *CloneBasicBlock(const BasicBlock *BB,
                             std::map<const Value*, Value*> &ValueMap,
-                            const char *NameSuffix = "", Function *F = 0);
+                            const char *NameSuffix = "", Function *F = 0,
+                            ClonedCodeInfo *CodeInfo = 0);
 
 
 /// CloneFunction - Return a copy of the specified function, but without
@@ -72,16 +103,18 @@ BasicBlock *CloneBasicBlock(const BasicBlock *BB,
 /// 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.
+/// the function from their old to new values.  The final argument captures
+/// information about the cloned code if non-null.
 ///
 Function *CloneFunction(const Function *F,
-                        std::map<const Value*, Value*> &ValueMap);
+                        std::map<const Value*, Value*> &ValueMap,
+                        ClonedCodeInfo *CodeInfo = 0);
 
 /// CloneFunction - Version of the function that doesn't need the ValueMap.
 ///
-inline Function *CloneFunction(const Function *F) {
+inline Function *CloneFunction(const Function *F, ClonedCodeInfo *CodeInfo = 0){
   std::map<const Value*, Value*> ValueMap;
-  return CloneFunction(F, ValueMap);
+  return CloneFunction(F, ValueMap, CodeInfo);
 }
 
 /// Clone OldFunc into NewFunc, transforming the old arguments into references
@@ -93,7 +126,8 @@ inline Function *CloneFunction(const Function *F) {
 void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
                        std::map<const Value*, Value*> &ValueMap,
                        std::vector<ReturnInst*> &Returns,
-                       const char *NameSuffix = "");
+                       const char *NameSuffix = "", 
+                       ClonedCodeInfo *CodeInfo = 0);
 
 
 /// CloneTraceInto - Clone T into NewFunc. Original<->clone mapping is
@@ -103,6 +137,12 @@ void CloneTraceInto(Function *NewFunc, Trace &T,
                     std::map<const Value*, Value*> &ValueMap,
                     const char *NameSuffix);
 
+/// CloneTrace - Returns a copy of the specified trace.
+/// It takes a vector of basic blocks clones the basic blocks, removes internal
+/// phi nodes, adds it to the same function as the original (although there is
+/// no jump to it) and returns the new vector of basic blocks.
+std::vector<BasicBlock *> CloneTrace(const std::vector<BasicBlock*> &origTrace);
+
 /// InlineFunction - This function inlines the called function into the basic
 /// block of the caller.  This returns false if it is not possible to inline
 /// this call.  The program is still in a well defined state if this occurs
@@ -113,15 +153,12 @@ void CloneTraceInto(Function *NewFunc, Trace &T,
 /// exists in the instruction stream.  Similiarly this will inline a recursive
 /// function by one level.
 ///
-bool InlineFunction(CallInst *C);
-bool InlineFunction(InvokeInst *II);
-bool InlineFunction(CallSite CS);
-
-/// CloneTrace - Returns a copy of the specified trace.
-/// It takes a vector of basic blocks clones the basic blocks, removes internal
-/// phi nodes, adds it to the same function as the original (although there is
-/// no jump to it) and returns the new vector of basic blocks.
-std::vector<BasicBlock *> CloneTrace(const std::vector<BasicBlock*> &origTrace);
+/// If a non-null callgraph pointer is provided, these functions update the
+/// CallGraph to represent the program after inlining.
+///
+bool InlineFunction(CallInst *C, CallGraph *CG = 0);
+bool InlineFunction(InvokeInst *II, CallGraph *CG = 0);
+bool InlineFunction(CallSite CS, CallGraph *CG = 0);
 
 } // End llvm namespace