LLVM  3.7.0
Classes | Namespaces | Macros | Functions | Variables
GVN.cpp File Reference
#include "llvm/Transforms/Scalar.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/CFG.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/Loads.h"
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/Analysis/PHITransAddr.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/PatternMatch.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/SSAUpdater.h"
#include <vector>
Include dependency graph for GVN.cpp:

Go to the source code of this file.

Classes

struct  llvm::DenseMapInfo< Expression >
 

Namespaces

 llvm
 Compute iterated dominance frontiers using a linear time algorithm.
 

Macros

#define DEBUG_TYPE   "gvn"
 

Functions

 STATISTIC (NumGVNInstr,"Number of instructions deleted")
 
 STATISTIC (NumGVNLoad,"Number of loads deleted")
 
 STATISTIC (NumGVNPRE,"Number of instructions PRE'd")
 
 STATISTIC (NumGVNBlocks,"Number of blocks merged")
 
 STATISTIC (NumGVNSimpl,"Number of instructions simplified")
 
 STATISTIC (NumGVNEqProp,"Number of equalities propagated")
 
 STATISTIC (NumPRELoad,"Number of loads PRE'd")
 
static bool IsValueFullyAvailableInBlock (BasicBlock *BB, DenseMap< BasicBlock *, char > &FullyAvailableBlocks, uint32_t RecurseDepth)
 Return true if we can prove that the value we're analyzing is fully available in the specified block. More...
 
static bool CanCoerceMustAliasedValueToLoad (Value *StoredVal, Type *LoadTy, const DataLayout &DL)
 Return true if CoerceAvailableValueToLoadType will succeed. More...
 
static ValueCoerceAvailableValueToLoadType (Value *StoredVal, Type *LoadedTy, IRBuilder<> &IRB, const DataLayout &DL)
 If we saw a store of a value to memory, and then a load from a must-aliased pointer of a different type, try to coerce the stored value. More...
 
static int AnalyzeLoadFromClobberingWrite (Type *LoadTy, Value *LoadPtr, Value *WritePtr, uint64_t WriteSizeInBits, const DataLayout &DL)
 This function is called when we have a memdep query of a load that ends up being a clobbering memory write (store, memset, memcpy, memmove). More...
 
static int AnalyzeLoadFromClobberingStore (Type *LoadTy, Value *LoadPtr, StoreInst *DepSI)
 This function is called when we have a memdep query of a load that ends up being a clobbering store. More...
 
static int AnalyzeLoadFromClobberingLoad (Type *LoadTy, Value *LoadPtr, LoadInst *DepLI, const DataLayout &DL)
 This function is called when we have a memdep query of a load that ends up being clobbered by another load. More...
 
static int AnalyzeLoadFromClobberingMemInst (Type *LoadTy, Value *LoadPtr, MemIntrinsic *MI, const DataLayout &DL)
 
static ValueGetStoreValueForLoad (Value *SrcVal, unsigned Offset, Type *LoadTy, Instruction *InsertPt, const DataLayout &DL)
 This function is called when we have a memdep query of a load that ends up being a clobbering store. More...
 
static ValueGetLoadValueForLoad (LoadInst *SrcVal, unsigned Offset, Type *LoadTy, Instruction *InsertPt, GVN &gvn)
 This function is called when we have a memdep query of a load that ends up being a clobbering load. More...
 
static ValueGetMemInstValueForLoad (MemIntrinsic *SrcInst, unsigned Offset, Type *LoadTy, Instruction *InsertPt, const DataLayout &DL)
 This function is called when we have a memdep query of a load that ends up being a clobbering mem intrinsic. More...
 
static ValueConstructSSAForLoadSet (LoadInst *LI, SmallVectorImpl< AvailableValueInBlock > &ValuesPerBlock, GVN &gvn)
 Given a set of loads specified by ValuesPerBlock, construct SSA form, allowing us to eliminate LI. More...
 
static bool isLifetimeStart (const Instruction *Inst)
 
static void patchReplacementInstruction (Instruction *I, Value *Repl)
 
static void patchAndReplaceAllUsesWith (Instruction *I, Value *Repl)
 
static bool isOnlyReachableViaThisEdge (const BasicBlockEdge &E, DominatorTree *DT)
 There is an edge from 'Src' to 'Dst'. More...
 

Variables

static cl::opt< boolEnablePRE ("enable-pre", cl::init(true), cl::Hidden)
 
static cl::opt< boolEnableLoadPRE ("enable-load-pre", cl::init(true))
 
static cl::opt< uint32_t > MaxRecurseDepth ("max-recurse-depth", cl::Hidden, cl::init(1000), cl::ZeroOrMore, cl::desc("Max recurse depth (default = 1000)"))
 

Macro Definition Documentation

#define DEBUG_TYPE   "gvn"

Definition at line 57 of file GVN.cpp.

Function Documentation

static int AnalyzeLoadFromClobberingLoad ( Type LoadTy,
Value LoadPtr,
LoadInst DepLI,
const DataLayout DL 
)
static

This function is called when we have a memdep query of a load that ends up being clobbered by another load.

See if the other load can feed into the second load.

Definition at line 1039 of file GVN.cpp.

References AnalyzeLoadFromClobberingWrite(), llvm::MemoryDependenceAnalysis::getLoadLoadClobberFullWidthSize(), llvm::GetPointerBaseWithConstantOffset(), llvm::LoadInst::getPointerOperand(), llvm::Value::getType(), llvm::DataLayout::getTypeSizeInBits(), llvm::DataLayout::getTypeStoreSize(), llvm::Type::isArrayTy(), and llvm::Type::isStructTy().

static int AnalyzeLoadFromClobberingMemInst ( Type LoadTy,
Value LoadPtr,
MemIntrinsic MI,
const DataLayout DL 
)
static
static int AnalyzeLoadFromClobberingStore ( Type LoadTy,
Value LoadPtr,
StoreInst DepSI 
)
static
static int AnalyzeLoadFromClobberingWrite ( Type LoadTy,
Value LoadPtr,
Value WritePtr,
uint64_t  WriteSizeInBits,
const DataLayout DL 
)
static

This function is called when we have a memdep query of a load that ends up being a clobbering memory write (store, memset, memcpy, memmove).

This means that the write may provide bits used by the load but we can't be sure because the pointers don't mustalias.

Check this case to see if there is anything more we can do before we give up. This returns -1 if we have to give up, or a byte number in the stored value of the piece that feeds the load.

Definition at line 947 of file GVN.cpp.

References llvm::dbgs(), llvm::GetPointerBaseWithConstantOffset(), llvm::DataLayout::getTypeSizeInBits(), llvm::Type::isArrayTy(), and llvm::Type::isStructTy().

Referenced by AnalyzeLoadFromClobberingLoad(), AnalyzeLoadFromClobberingMemInst(), and AnalyzeLoadFromClobberingStore().

static bool CanCoerceMustAliasedValueToLoad ( Value StoredVal,
Type LoadTy,
const DataLayout DL 
)
static

Return true if CoerceAvailableValueToLoadType will succeed.

Definition at line 838 of file GVN.cpp.

References llvm::Value::getType(), llvm::DataLayout::getTypeSizeInBits(), llvm::Type::isArrayTy(), and llvm::Type::isStructTy().

Referenced by CoerceAvailableValueToLoadType().

static Value* CoerceAvailableValueToLoadType ( Value StoredVal,
Type LoadedTy,
IRBuilder<> &  IRB,
const DataLayout DL 
)
static
static Value* ConstructSSAForLoadSet ( LoadInst LI,
SmallVectorImpl< AvailableValueInBlock > &  ValuesPerBlock,
GVN &  gvn 
)
static
static Value* GetLoadValueForLoad ( LoadInst SrcVal,
unsigned  Offset,
Type LoadTy,
Instruction InsertPt,
GVN &  gvn 
)
static
static Value* GetMemInstValueForLoad ( MemIntrinsic SrcInst,
unsigned  Offset,
Type LoadTy,
Instruction InsertPt,
const DataLayout DL 
)
static
static Value* GetStoreValueForLoad ( Value SrcVal,
unsigned  Offset,
Type LoadTy,
Instruction InsertPt,
const DataLayout DL 
)
static
static bool isLifetimeStart ( const Instruction Inst)
static

Definition at line 1364 of file GVN.cpp.

static bool isOnlyReachableViaThisEdge ( const BasicBlockEdge E,
DominatorTree DT 
)
static

There is an edge from 'Src' to 'Dst'.

Return true if every path from the entry block to 'Dst' passes via this edge. In particular 'Dst' must not be reachable via another edge from 'Src'.

Definition at line 2037 of file GVN.cpp.

References llvm::BasicBlockEdge::getEnd(), llvm::BasicBlock::getSinglePredecessor(), and llvm::BasicBlockEdge::getStart().

static bool IsValueFullyAvailableInBlock ( BasicBlock BB,
DenseMap< BasicBlock *, char > &  FullyAvailableBlocks,
uint32_t  RecurseDepth 
)
static

Return true if we can prove that the value we're analyzing is fully available in the specified block.

As we go, keep track of which blocks we know are fully alive in FullyAvailableBlocks. This map is actually a tri-state map with the following values: 0) we know the block is not fully available. 1) we know the block is fully available. 2) we do not know whether the block is fully available or not, but we are currently speculating that it will be. 3) we are speculating for this block and have used that to speculate for other blocks.

Definition at line 766 of file GVN.cpp.

References llvm::SmallVectorImpl< T >::append(), llvm::SmallVectorBase::empty(), llvm::DenseMapBase< DenseMap< KeyT, ValueT, KeyInfoT, BucketT >, KeyT, ValueT, KeyInfoT, BucketT >::insert(), MaxRecurseDepth, llvm::SmallVectorImpl< T >::pop_back_val(), llvm::pred_begin(), llvm::pred_end(), llvm::SmallVectorTemplateBase< T, isPodLike< T >::value >::push_back(), llvm::succ_begin(), and llvm::succ_end().

static void patchAndReplaceAllUsesWith ( Instruction I,
Value Repl 
)
static

Definition at line 1810 of file GVN.cpp.

References patchReplacementInstruction(), and llvm::Value::replaceAllUsesWith().

static void patchReplacementInstruction ( Instruction I,
Value Repl 
)
static
STATISTIC ( NumGVNInstr  ,
"Number of instructions deleted"   
)
STATISTIC ( NumGVNLoad  ,
"Number of loads deleted"   
)
STATISTIC ( NumGVNPRE  ,
"Number of instructions PRE'd"   
)
STATISTIC ( NumGVNBlocks  ,
"Number of blocks merged"   
)
STATISTIC ( NumGVNSimpl  ,
"Number of instructions simplified"   
)
STATISTIC ( NumGVNEqProp  ,
"Number of equalities propagated"   
)
STATISTIC ( NumPRELoad  ,
"Number of loads PRE'd"   
)

Variable Documentation

cl::opt<bool> EnableLoadPRE("enable-load-pre", cl::init(true))
static
cl::opt<bool> EnablePRE("enable-pre", cl::init(true), cl::Hidden)
static
cl::opt<uint32_t> MaxRecurseDepth("max-recurse-depth", cl::Hidden, cl::init(1000), cl::ZeroOrMore, cl::desc("Max recurse depth (default = 1000)"))
static