LLVM  4.0.0
Classes | Namespaces | Macros | Functions | Variables
GVN.cpp File Reference
#include "llvm/Transforms/Scalar/GVN.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/GlobalsModRef.h"
#include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/Loads.h"
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/Analysis/OptimizationDiagnosticInfo.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/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::GVN::Expression
 
struct  llvm::DenseMapInfo< GVN::Expression >
 
struct  llvm::gvn::AvailableValue
 Represents a particular available value that we know how to materialize. More...
 
struct  llvm::gvn::AvailableValueInBlock
 Represents an AvailableValue which can be rematerialized at the end of the associated BasicBlock. More...
 
class  llvm::gvn::GVNLegacyPass
 

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 reportMayClobberedLoad (LoadInst *LI, MemDepResult DepInfo, DominatorTree *DT, OptimizationRemarkEmitter *ORE)
 Try to locate the three instruction involved in a missed load-elimination case that is due to an intervening store. More...
 
static void reportLoadElim (LoadInst *LI, Value *AvailableValue, OptimizationRemarkEmitter *ORE)
 
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_tMaxRecurseDepth ("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 59 of file GVN.cpp.

Referenced by reportLoadElim(), and reportMayClobberedLoad().

Function Documentation

static int AnalyzeLoadFromClobberingLoad ( Type LoadTy,
Value LoadPtr,
LoadInst DepLI,
const DataLayout DL 
)
static
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 820 of file GVN.cpp.

References 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 694 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 1206 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 1911 of file GVN.cpp.

References assert(), 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 622 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 1822 of file GVN.cpp.

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

static void patchReplacementInstruction ( Instruction I,
Value Repl 
)
static
static void reportLoadElim ( LoadInst LI,
Value AvailableValue,
OptimizationRemarkEmitter ORE 
)
static
static void reportMayClobberedLoad ( LoadInst LI,
MemDepResult  DepInfo,
DominatorTree DT,
OptimizationRemarkEmitter ORE 
)
static

Try to locate the three instruction involved in a missed load-elimination case that is due to an intervening store.

Definition at line 1214 of file GVN.cpp.

References DEBUG_TYPE, llvm::DominatorTree::dominates(), llvm::OptimizationRemarkEmitter::emit(), llvm::MemDepResult::getInst(), llvm::LoadInst::getPointerOperand(), llvm::Value::getType(), and llvm::Value::users().

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