LCOV - code coverage report
Current view: top level - include/llvm/Transforms/Utils - Cloning.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 8 8 100.0 %
Date: 2017-09-14 15:23:50 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/SmallVector.h"
      22             : #include "llvm/ADT/Twine.h"
      23             : #include "llvm/Analysis/AliasAnalysis.h"
      24             : #include "llvm/Analysis/AssumptionCache.h"
      25             : #include "llvm/IR/CallSite.h"
      26             : #include "llvm/IR/ValueHandle.h"
      27             : #include "llvm/Transforms/Utils/ValueMapper.h"
      28             : #include <functional>
      29             : #include <memory>
      30             : #include <vector>
      31             : 
      32             : namespace llvm {
      33             : 
      34             : class AllocaInst;
      35             : class BasicBlock;
      36             : class BlockFrequencyInfo;
      37             : class CallInst;
      38             : class CallGraph;
      39             : class DebugInfoFinder;
      40             : class DominatorTree;
      41             : class Function;
      42             : class Instruction;
      43             : class InvokeInst;
      44             : class Loop;
      45             : class LoopInfo;
      46             : class Module;
      47             : class ProfileSummaryInfo;
      48             : class ReturnInst;
      49             : 
      50             : /// Return an exact copy of the specified module
      51             : ///
      52             : std::unique_ptr<Module> CloneModule(const Module *M);
      53             : std::unique_ptr<Module> CloneModule(const Module *M, ValueToValueMapTy &VMap);
      54             : 
      55             : /// Return a copy of the specified module. The ShouldCloneDefinition function
      56             : /// controls whether a specific GlobalValue's definition is cloned. If the
      57             : /// function returns false, the module copy will contain an external reference
      58             : /// in place of the global definition.
      59             : std::unique_ptr<Module>
      60             : CloneModule(const Module *M, ValueToValueMapTy &VMap,
      61             :             function_ref<bool(const GlobalValue *)> ShouldCloneDefinition);
      62             : 
      63             : /// ClonedCodeInfo - This struct can be used to capture information about code
      64             : /// being cloned, while it is being cloned.
      65       88002 : struct ClonedCodeInfo {
      66             :   /// ContainsCalls - This is set to true if the cloned code contains a normal
      67             :   /// call instruction.
      68             :   bool ContainsCalls = false;
      69             : 
      70             :   /// ContainsDynamicAllocas - This is set to true if the cloned code contains
      71             :   /// a 'dynamic' alloca.  Dynamic allocas are allocas that are either not in
      72             :   /// the entry block or they are in the entry block but are not a constant
      73             :   /// size.
      74             :   bool ContainsDynamicAllocas = false;
      75             : 
      76             :   /// All cloned call sites that have operand bundles attached are appended to
      77             :   /// this vector.  This vector may contain nulls or undefs if some of the
      78             :   /// originally inserted callsites were DCE'ed after they were cloned.
      79             :   std::vector<WeakTrackingVH> OperandBundleCallSites;
      80             : 
      81      176004 :   ClonedCodeInfo() = default;
      82             : };
      83             : 
      84             : /// CloneBasicBlock - Return a copy of the specified basic block, but without
      85             : /// embedding the block into a particular function.  The block returned is an
      86             : /// exact copy of the specified basic block, without any remapping having been
      87             : /// performed.  Because of this, this is only suitable for applications where
      88             : /// the basic block will be inserted into the same function that it was cloned
      89             : /// from (loop unrolling would use this, for example).
      90             : ///
      91             : /// Also, note that this function makes a direct copy of the basic block, and
      92             : /// can thus produce illegal LLVM code.  In particular, it will copy any PHI
      93             : /// nodes from the original block, even though there are no predecessors for the
      94             : /// newly cloned block (thus, phi nodes will have to be updated).  Also, this
      95             : /// block will branch to the old successors of the original block: these
      96             : /// successors will have to have any PHI nodes updated to account for the new
      97             : /// incoming edges.
      98             : ///
      99             : /// The correlation between instructions in the source and result basic blocks
     100             : /// is recorded in the VMap map.
     101             : ///
     102             : /// If you have a particular suffix you'd like to use to add to any cloned
     103             : /// names, specify it as the optional third parameter.
     104             : ///
     105             : /// If you would like the basic block to be auto-inserted into the end of a
     106             : /// function, you can specify it as the optional fourth parameter.
     107             : ///
     108             : /// If you would like to collect additional information about the cloned
     109             : /// function, you can specify a ClonedCodeInfo object with the optional fifth
     110             : /// parameter.
     111             : ///
     112             : BasicBlock *CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap,
     113             :                             const Twine &NameSuffix = "", Function *F = nullptr,
     114             :                             ClonedCodeInfo *CodeInfo = nullptr,
     115             :                             DebugInfoFinder *DIFinder = nullptr);
     116             : 
     117             : /// CloneFunction - Return a copy of the specified function and add it to that
     118             : /// function's module.  Also, any references specified in the VMap are changed
     119             : /// to refer to their mapped value instead of the original one.  If any of the
     120             : /// arguments to the function are in the VMap, the arguments are deleted from
     121             : /// the resultant function.  The VMap is updated to include mappings from all of
     122             : /// the instructions and basicblocks in the function from their old to new
     123             : /// values.  The final argument captures information about the cloned code if
     124             : /// non-null.
     125             : ///
     126             : /// VMap contains no non-identity GlobalValue mappings and debug info metadata
     127             : /// will not be cloned.
     128             : ///
     129             : Function *CloneFunction(Function *F, ValueToValueMapTy &VMap,
     130             :                         ClonedCodeInfo *CodeInfo = nullptr);
     131             : 
     132             : /// Clone OldFunc into NewFunc, transforming the old arguments into references
     133             : /// to VMap values.  Note that if NewFunc already has basic blocks, the ones
     134             : /// cloned into it will be added to the end of the function.  This function
     135             : /// fills in a list of return instructions, and can optionally remap types
     136             : /// and/or append the specified suffix to all values cloned.
     137             : ///
     138             : /// If ModuleLevelChanges is false, VMap contains no non-identity GlobalValue
     139             : /// mappings.
     140             : ///
     141             : void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
     142             :                        ValueToValueMapTy &VMap, bool ModuleLevelChanges,
     143             :                        SmallVectorImpl<ReturnInst*> &Returns,
     144             :                        const char *NameSuffix = "",
     145             :                        ClonedCodeInfo *CodeInfo = nullptr,
     146             :                        ValueMapTypeRemapper *TypeMapper = nullptr,
     147             :                        ValueMaterializer *Materializer = nullptr);
     148             : 
     149             : void CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
     150             :                                const Instruction *StartingInst,
     151             :                                ValueToValueMapTy &VMap, bool ModuleLevelChanges,
     152             :                                SmallVectorImpl<ReturnInst *> &Returns,
     153             :                                const char *NameSuffix = "",
     154             :                                ClonedCodeInfo *CodeInfo = nullptr);
     155             : 
     156             : /// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto,
     157             : /// except that it does some simple constant prop and DCE on the fly.  The
     158             : /// effect of this is to copy significantly less code in cases where (for
     159             : /// example) a function call with constant arguments is inlined, and those
     160             : /// constant arguments cause a significant amount of code in the callee to be
     161             : /// dead.  Since this doesn't produce an exactly copy of the input, it can't be
     162             : /// used for things like CloneFunction or CloneModule.
     163             : ///
     164             : /// If ModuleLevelChanges is false, VMap contains no non-identity GlobalValue
     165             : /// mappings.
     166             : ///
     167             : void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
     168             :                                ValueToValueMapTy &VMap, bool ModuleLevelChanges,
     169             :                                SmallVectorImpl<ReturnInst*> &Returns,
     170             :                                const char *NameSuffix = "",
     171             :                                ClonedCodeInfo *CodeInfo = nullptr,
     172             :                                Instruction *TheCall = nullptr);
     173             : 
     174             : /// InlineFunctionInfo - This class captures the data input to the
     175             : /// InlineFunction call, and records the auxiliary results produced by it.
     176      191592 : class InlineFunctionInfo {
     177             : public:
     178             :   explicit InlineFunctionInfo(CallGraph *cg = nullptr,
     179             :                               std::function<AssumptionCache &(Function &)>
     180             :                                   *GetAssumptionCache = nullptr,
     181             :                               ProfileSummaryInfo *PSI = nullptr,
     182             :                               BlockFrequencyInfo *CallerBFI = nullptr,
     183             :                               BlockFrequencyInfo *CalleeBFI = nullptr)
     184       47898 :       : CG(cg), GetAssumptionCache(GetAssumptionCache), PSI(PSI),
     185      191592 :         CallerBFI(CallerBFI), CalleeBFI(CalleeBFI) {}
     186             : 
     187             :   /// CG - If non-null, InlineFunction will update the callgraph to reflect the
     188             :   /// changes it makes.
     189             :   CallGraph *CG;
     190             :   std::function<AssumptionCache &(Function &)> *GetAssumptionCache;
     191             :   ProfileSummaryInfo *PSI;
     192             :   BlockFrequencyInfo *CallerBFI, *CalleeBFI;
     193             : 
     194             :   /// StaticAllocas - InlineFunction fills this in with all static allocas that
     195             :   /// get copied into the caller.
     196             :   SmallVector<AllocaInst *, 4> StaticAllocas;
     197             : 
     198             :   /// InlinedCalls - InlineFunction fills this in with callsites that were
     199             :   /// inlined from the callee.  This is only filled in if CG is non-null.
     200             :   SmallVector<WeakTrackingVH, 8> InlinedCalls;
     201             : 
     202             :   /// All of the new call sites inlined into the caller.
     203             :   ///
     204             :   /// 'InlineFunction' fills this in by scanning the inlined instructions, and
     205             :   /// only if CG is null. If CG is non-null, instead the value handle
     206             :   /// `InlinedCalls` above is used.
     207             :   SmallVector<CallSite, 8> InlinedCallSites;
     208             : 
     209             :   void reset() {
     210      176680 :     StaticAllocas.clear();
     211      176680 :     InlinedCalls.clear();
     212      176680 :     InlinedCallSites.clear();
     213             :   }
     214             : };
     215             : 
     216             : /// InlineFunction - This function inlines the called function into the basic
     217             : /// block of the caller.  This returns false if it is not possible to inline
     218             : /// this call.  The program is still in a well defined state if this occurs
     219             : /// though.
     220             : ///
     221             : /// Note that this only does one level of inlining.  For example, if the
     222             : /// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now
     223             : /// exists in the instruction stream.  Similarly this will inline a recursive
     224             : /// function by one level.
     225             : ///
     226             : /// Note that while this routine is allowed to cleanup and optimize the
     227             : /// *inlined* code to minimize the actual inserted code, it must not delete
     228             : /// code in the caller as users of this routine may have pointers to
     229             : /// instructions in the caller that need to remain stable.
     230             : bool InlineFunction(CallInst *C, InlineFunctionInfo &IFI,
     231             :                     AAResults *CalleeAAR = nullptr, bool InsertLifetime = true);
     232             : bool InlineFunction(InvokeInst *II, InlineFunctionInfo &IFI,
     233             :                     AAResults *CalleeAAR = nullptr, bool InsertLifetime = true);
     234             : bool InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
     235             :                     AAResults *CalleeAAR = nullptr, bool InsertLifetime = true);
     236             : 
     237             : /// \brief Clones a loop \p OrigLoop.  Returns the loop and the blocks in \p
     238             : /// Blocks.
     239             : ///
     240             : /// Updates LoopInfo and DominatorTree assuming the loop is dominated by block
     241             : /// \p LoopDomBB.  Insert the new blocks before block specified in \p Before.
     242             : /// Note: Only innermost loops are supported.
     243             : Loop *cloneLoopWithPreheader(BasicBlock *Before, BasicBlock *LoopDomBB,
     244             :                              Loop *OrigLoop, ValueToValueMapTy &VMap,
     245             :                              const Twine &NameSuffix, LoopInfo *LI,
     246             :                              DominatorTree *DT,
     247             :                              SmallVectorImpl<BasicBlock *> &Blocks);
     248             : 
     249             : /// \brief Remaps instructions in \p Blocks using the mapping in \p VMap.
     250             : void remapInstructionsInBlocks(const SmallVectorImpl<BasicBlock *> &Blocks,
     251             :                                ValueToValueMapTy &VMap);
     252             : 
     253             : /// Split edge between BB and PredBB and duplicate all non-Phi instructions
     254             : /// from BB between its beginning and the StopAt instruction into the split
     255             : /// block. Phi nodes are not duplicated, but their uses are handled correctly:
     256             : /// we replace them with the uses of corresponding Phi inputs. ValueMapping
     257             : /// is used to map the original instructions from BB to their newly-created
     258             : /// copies. Returns the split block.
     259             : BasicBlock *
     260             : DuplicateInstructionsInSplitBetween(BasicBlock *BB, BasicBlock *PredBB,
     261             :                                     Instruction *StopAt,
     262             :                                     ValueToValueMapTy &ValueMapping);
     263             : } // end namespace llvm
     264             : 
     265             : #endif // LLVM_TRANSFORMS_UTILS_CLONING_H

Generated by: LCOV version 1.13