Cloning.h File Reference

#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/InlineCost.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Transforms/Utils/ValueMapper.h"
#include <functional>
#include <memory>
#include <vector>

Go to the source code of this file.

Classes
struct	llvm::ClonedCodeInfo
	This struct can be used to capture information about code being cloned, while it is being cloned. More...
class	llvm::InlineFunctionInfo
	This class captures the data input to the InlineFunction call, and records the auxiliary results produced by it. More...

Namespaces
namespace	llvm
	This is an optimization pass for GlobalISel generic memory operations.

Enumerations
enum class	llvm::CloneFunctionChangeType { llvm::LocalChangesOnly , llvm::GlobalChanges , llvm::DifferentModule , llvm::ClonedModule }

Functions
std::unique_ptr< Module >	llvm::CloneModule (const Module &M)
	Return an exact copy of the specified module.
std::unique_ptr< Module >	llvm::CloneModule (const Module &M, ValueToValueMapTy &VMap)
std::unique_ptr< Module >	llvm::CloneModule (const Module &M, ValueToValueMapTy &VMap, function_ref< bool(const GlobalValue *)> ShouldCloneDefinition)
	Return a copy of the specified module.
BasicBlock *	llvm::CloneBasicBlock (const BasicBlock *BB, ValueToValueMapTy &VMap, const Twine &NameSuffix="", Function *F=nullptr, ClonedCodeInfo *CodeInfo=nullptr)
	Return a copy of the specified basic block, but without embedding the block into a particular function.
Function *	llvm::CloneFunction (Function *F, ValueToValueMapTy &VMap, ClonedCodeInfo *CodeInfo=nullptr)
	Return a copy of the specified function and add it to that function's module.
void	llvm::CloneFunctionInto (Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, CloneFunctionChangeType Changes, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
	Clone OldFunc into NewFunc, transforming the old arguments into references to VMap values.
void	llvm::CloneFunctionAttributesInto (Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
	Clone OldFunc's attributes into NewFunc, transforming values based on the mappings in VMap.
void	llvm::CloneFunctionMetadataInto (Function &NewFunc, const Function &OldFunc, ValueToValueMapTy &VMap, RemapFlags RemapFlag, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
	Clone OldFunc's metadata into NewFunc.
void	llvm::CloneFunctionBodyInto (Function &NewFunc, const Function &OldFunc, ValueToValueMapTy &VMap, RemapFlags RemapFlag, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
	Clone OldFunc's body into NewFunc.
void	llvm::CloneAndPruneIntoFromInst (Function *NewFunc, const Function *OldFunc, const Instruction *StartingInst, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr)
	This works like CloneAndPruneFunctionInto, except that it does not clone the entire function.
void	llvm::CloneAndPruneFunctionInto (Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr)
	This works exactly like CloneFunctionInto, except that it does some simple constant prop and DCE on the fly.
DISubprogram *	llvm::CollectDebugInfoForCloning (const Function &F, CloneFunctionChangeType Changes, DebugInfoFinder &DIFinder)
	Collect debug information such as types, compile units, and other subprograms that are reachable from F and can be considered global for the purposes of cloning (and hence not needing to be cloned).
bool	llvm::BuildDebugInfoMDMap (DenseMap< const Metadata *, TrackingMDRef > &MD, CloneFunctionChangeType Changes, DebugInfoFinder &DIFinder, DISubprogram *SPClonedWithinModule)
	Build a map of debug info to use during Metadata cloning.
InlineResult	llvm::InlineFunction (CallBase &CB, InlineFunctionInfo &IFI, bool MergeAttributes=false, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true, Function *ForwardVarArgsTo=nullptr)
	This function inlines the called function into the basic block of the caller.
InlineResult	llvm::InlineFunction (CallBase &CB, InlineFunctionInfo &IFI, PGOContextualProfile &CtxProf, bool MergeAttributes=false, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true, Function *ForwardVarArgsTo=nullptr)
	Same as above, but it will update the contextual profile.
Loop *	llvm::cloneLoopWithPreheader (BasicBlock *Before, BasicBlock *LoopDomBB, Loop *OrigLoop, ValueToValueMapTy &VMap, const Twine &NameSuffix, LoopInfo *LI, DominatorTree *DT, SmallVectorImpl< BasicBlock * > &Blocks)
	Clones a loop OrigLoop.
void	llvm::remapInstructionsInBlocks (ArrayRef< BasicBlock * > Blocks, ValueToValueMapTy &VMap)
	Remaps instructions in Blocks using the mapping in VMap.
BasicBlock *	llvm::DuplicateInstructionsInSplitBetween (BasicBlock *BB, BasicBlock *PredBB, Instruction *StopAt, ValueToValueMapTy &ValueMapping, DomTreeUpdater &DTU)
	Split edge between BB and PredBB and duplicate all non-Phi instructions from BB between its beginning and the StopAt instruction into the split block.
void	llvm::updateProfileCallee (Function *Callee, int64_t EntryDelta, const ValueMap< const Value *, WeakTrackingVH > *VMap=nullptr)
	Updates profile information by adjusting the entry count by adding EntryDelta then scaling callsite information by the new count divided by the old count.
void	llvm::identifyNoAliasScopesToClone (ArrayRef< BasicBlock * > BBs, SmallVectorImpl< MDNode * > &NoAliasDeclScopes)
	Find the 'llvm.experimental.noalias.scope.decl' intrinsics in the specified basic blocks and extract their scope.
void	llvm::identifyNoAliasScopesToClone (BasicBlock::iterator Start, BasicBlock::iterator End, SmallVectorImpl< MDNode * > &NoAliasDeclScopes)
	Find the 'llvm.experimental.noalias.scope.decl' intrinsics in the specified instruction range and extract their scope.
void	llvm::cloneNoAliasScopes (ArrayRef< MDNode * > NoAliasDeclScopes, DenseMap< MDNode *, MDNode * > &ClonedScopes, StringRef Ext, LLVMContext &Context)
	Duplicate the specified list of noalias decl scopes.
void	llvm::adaptNoAliasScopes (llvm::Instruction *I, const DenseMap< MDNode *, MDNode * > &ClonedScopes, LLVMContext &Context)
	Adapt the metadata for the specified instruction according to the provided mapping.
void	llvm::cloneAndAdaptNoAliasScopes (ArrayRef< MDNode * > NoAliasDeclScopes, ArrayRef< BasicBlock * > NewBlocks, LLVMContext &Context, StringRef Ext)
	Clone the specified noalias decl scopes.
void	llvm::cloneAndAdaptNoAliasScopes (ArrayRef< MDNode * > NoAliasDeclScopes, Instruction *IStart, Instruction *IEnd, LLVMContext &Context, StringRef Ext)
	Clone the specified noalias decl scopes.