|
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| bool | llvm::isDereferenceableReadOnlyLoop (Loop *L, ScalarEvolution *SE, DominatorTree *DT, AssumptionCache *AC, SmallVectorImpl< const SCEVPredicate * > *Predicates=nullptr) |
| | Return true if the loop L cannot fault on any iteration and only contains read-only memory accesses.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| 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.
|
| |
| bool | llvm::canReplacePointersInUseIfEqual (const Use &U, const Value *To, const DataLayout &DL) |
| |
