Loads.h File Reference

#include "llvm/ADT/APInt.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/GEPNoWrapFlags.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"

Go to the source code of this file.

Classes
struct	llvm::LinearExpression
	Linear expression BasePtr + Index * Scale + Offset. More...

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

Functions
LLVM_ABI bool	llvm::isDereferenceablePointer (const Value *V, Type *Ty, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
	Return true if this is always a dereferenceable pointer.
LLVM_ABI bool	llvm::isDereferenceableAndAlignedPointer (const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
	Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
LLVM_ABI bool	llvm::isDereferenceableAndAlignedPointer (const Value *V, Align Alignment, const APInt &Size, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
	Returns true if V is always dereferenceable for Size byte with alignment greater or equal than requested.
LLVM_ABI bool	llvm::isSafeToLoadUnconditionally (Value *V, Align Alignment, const APInt &Size, const DataLayout &DL, Instruction *ScanFrom, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
	Return true if we know that executing a load from this value cannot trap.
LLVM_ABI bool	llvm::isDereferenceableAndAlignedInLoop (LoadInst *LI, Loop *L, ScalarEvolution &SE, DominatorTree &DT, AssumptionCache *AC=nullptr, SmallVectorImpl< const SCEVPredicate * > *Predicates=nullptr)
	Return true if we can prove that the given load (which is assumed to be within the specified loop) would access only dereferenceable memory, and be properly aligned on every iteration of the specified loop regardless of its placement within the loop.
LLVM_ABI bool	llvm::isReadOnlyLoop (Loop *L, ScalarEvolution *SE, DominatorTree *DT, AssumptionCache *AC, SmallVectorImpl< LoadInst * > &NonDereferenceableAndAlignedLoads, SmallVectorImpl< const SCEVPredicate * > *Predicates=nullptr)
	Returns true if the loop contains read-only memory accesses and doesn't throw.
LLVM_ABI bool	llvm::isSafeToLoadUnconditionally (Value *V, Type *Ty, Align Alignment, const DataLayout &DL, Instruction *ScanFrom, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
	Return true if we know that executing a load from this value cannot trap.
LLVM_ABI bool	llvm::mustSuppressSpeculation (const LoadInst &LI)
	Return true if speculation of the given load must be suppressed to avoid ordering or interfering with an active sanitizer.
LLVM_ABI Value *	llvm::FindAvailableLoadedValue (LoadInst *Load, BasicBlock *ScanBB, BasicBlock::iterator &ScanFrom, unsigned MaxInstsToScan=DefMaxInstsToScan, BatchAAResults *AA=nullptr, bool *IsLoadCSE=nullptr, unsigned *NumScanedInst=nullptr)
	Scan backwards to see if we have the value of the given load available locally within a small number of instructions.
LLVM_ABI Value *	llvm::FindAvailableLoadedValue (LoadInst *Load, BatchAAResults &AA, bool *IsLoadCSE, unsigned MaxInstsToScan=DefMaxInstsToScan)
	This overload provides a more efficient implementation of FindAvailableLoadedValue() for the case where we are not interested in finding the closest clobbering instruction if no available load is found.
LLVM_ABI Value *	llvm::findAvailablePtrLoadStore (const MemoryLocation &Loc, Type *AccessTy, bool AtLeastAtomic, BasicBlock *ScanBB, BasicBlock::iterator &ScanFrom, unsigned MaxInstsToScan, BatchAAResults *AA, bool *IsLoadCSE, unsigned *NumScanedInst)
	Scan backwards to see if we have the value of the given pointer available locally within a small number of instructions.
LLVM_ABI bool	llvm::canReplacePointersIfEqual (const Value *From, const Value *To, const DataLayout &DL)
	Returns true if a pointer value From can be replaced with another pointer value \To if they are deemed equal through some means (e.g.
LLVM_ABI bool	llvm::canReplacePointersInUseIfEqual (const Use &U, const Value *To, const DataLayout &DL)
LLVM_ABI LinearExpression	llvm::decomposeLinearExpression (const DataLayout &DL, Value *Ptr)
	Decompose a pointer into a linear expression.

Variables
LLVM_ABI cl::opt< unsigned >	llvm::DefMaxInstsToScan
	The default number of maximum instructions to scan in the block, used by FindAvailableLoadedValue().