1//===- Loads.h - Local load analysis --------------------------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file declares simple local analyses for load instructions. 10// 11//===----------------------------------------------------------------------===// 12 13#ifndef LLVM_ANALYSIS_LOADS_H 14#define LLVM_ANALYSIS_LOADS_H 15 16#include "llvm/IR/BasicBlock.h" 17#include "llvm/Support/CommandLine.h" 18 19namespace llvm { 20 21class AAResults; 22class DataLayout; 23class DominatorTree; 24class Instruction; 25class LoadInst; 26class Loop; 27class MDNode; 28class MemoryLocation; 29class ScalarEvolution; 30class TargetLibraryInfo; 31 32/// Return true if this is always a dereferenceable pointer. If the context 33/// instruction is specified perform context-sensitive analysis and return true 34/// if the pointer is dereferenceable at the specified instruction. 35bool isDereferenceablePointer(const Value *V, Type *Ty, 36 const DataLayout &DL, 37 const Instruction *CtxI = nullptr, 38 const DominatorTree *DT = nullptr, 39 const TargetLibraryInfo *TLI = nullptr); 40 41/// Returns true if V is always a dereferenceable pointer with alignment 42/// greater or equal than requested. If the context instruction is specified 43/// performs context-sensitive analysis and returns true if the pointer is 44/// dereferenceable at the specified instruction. 45bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, 46 MaybeAlign Alignment, 47 const DataLayout &DL, 48 const Instruction *CtxI = nullptr, 49 const DominatorTree *DT = nullptr, 50 const TargetLibraryInfo *TLI = nullptr); 51 52/// Returns true if V is always dereferenceable for Size byte with alignment 53/// greater or equal than requested. If the context instruction is specified 54/// performs context-sensitive analysis and returns true if the pointer is 55/// dereferenceable at the specified instruction. 56bool isDereferenceableAndAlignedPointer(const Value *V, Align Alignment, 57 const APInt &Size, const DataLayout &DL, 58 const Instruction *CtxI = nullptr, 59 const DominatorTree *DT = nullptr, 60 const TargetLibraryInfo *TLI = nullptr); 61 62/// Return true if we know that executing a load from this value cannot trap. 63/// 64/// If DT and ScanFrom are specified this method performs context-sensitive 65/// analysis and returns true if it is safe to load immediately before ScanFrom. 66/// 67/// If it is not obviously safe to load from the specified pointer, we do a 68/// quick local scan of the basic block containing ScanFrom, to determine if 69/// the address is already accessed. 70bool isSafeToLoadUnconditionally(Value *V, Align Alignment, APInt &Size, 71 const DataLayout &DL, 72 Instruction *ScanFrom = nullptr, 73 const DominatorTree *DT = nullptr, 74 const TargetLibraryInfo *TLI = nullptr); 75 76/// Return true if we can prove that the given load (which is assumed to be 77/// within the specified loop) would access only dereferenceable memory, and 78/// be properly aligned on every iteration of the specified loop regardless of 79/// its placement within the loop. (i.e. does not require predication beyond 80/// that required by the the header itself and could be hoisted into the header 81/// if desired.) This is more powerful than the variants above when the 82/// address loaded from is analyzeable by SCEV. 83bool isDereferenceableAndAlignedInLoop(LoadInst *LI, Loop *L, 84 ScalarEvolution &SE, 85 DominatorTree &DT); 86 87/// Return true if we know that executing a load from this value cannot trap. 88/// 89/// If DT and ScanFrom are specified this method performs context-sensitive 90/// analysis and returns true if it is safe to load immediately before ScanFrom. 91/// 92/// If it is not obviously safe to load from the specified pointer, we do a 93/// quick local scan of the basic block containing ScanFrom, to determine if 94/// the address is already accessed. 95bool isSafeToLoadUnconditionally(Value *V, Type *Ty, Align Alignment, 96 const DataLayout &DL, 97 Instruction *ScanFrom = nullptr, 98 const DominatorTree *DT = nullptr, 99 const TargetLibraryInfo *TLI = nullptr); 100 101/// The default number of maximum instructions to scan in the block, used by 102/// FindAvailableLoadedValue(). 103extern cl::opt<unsigned> DefMaxInstsToScan; 104 105/// Scan backwards to see if we have the value of the given load available 106/// locally within a small number of instructions. 107/// 108/// You can use this function to scan across multiple blocks: after you call 109/// this function, if ScanFrom points at the beginning of the block, it's safe 110/// to continue scanning the predecessors. 111/// 112/// Note that performing load CSE requires special care to make sure the 113/// metadata is set appropriately. In particular, aliasing metadata needs 114/// to be merged. (This doesn't matter for store-to-load forwarding because 115/// the only relevant load gets deleted.) 116/// 117/// \param Load The load we want to replace. 118/// \param ScanBB The basic block to scan. 119/// \param [in,out] ScanFrom The location to start scanning from. When this 120/// function returns, it points at the last instruction scanned. 121/// \param MaxInstsToScan The maximum number of instructions to scan. If this 122/// is zero, the whole block will be scanned. 123/// \param AA Optional pointer to alias analysis, to make the scan more 124/// precise. 125/// \param [out] IsLoadCSE Whether the returned value is a load from the same 126/// location in memory, as opposed to the value operand of a store. 127/// 128/// \returns The found value, or nullptr if no value is found. 129Value *FindAvailableLoadedValue(LoadInst *Load, 130 BasicBlock *ScanBB, 131 BasicBlock::iterator &ScanFrom, 132 unsigned MaxInstsToScan = DefMaxInstsToScan, 133 AAResults *AA = nullptr, 134 bool *IsLoadCSE = nullptr, 135 unsigned *NumScanedInst = nullptr); 136 137/// This overload provides a more efficient implementation of 138/// FindAvailableLoadedValue() for the case where we are not interested in 139/// finding the closest clobbering instruction if no available load is found. 140/// This overload cannot be used to scan across multiple blocks. 141Value *FindAvailableLoadedValue(LoadInst *Load, AAResults &AA, bool *IsLoadCSE, 142 unsigned MaxInstsToScan = DefMaxInstsToScan); 143 144/// Scan backwards to see if we have the value of the given pointer available 145/// locally within a small number of instructions. 146/// 147/// You can use this function to scan across multiple blocks: after you call 148/// this function, if ScanFrom points at the beginning of the block, it's safe 149/// to continue scanning the predecessors. 150/// 151/// \param Loc The location we want the load and store to originate from. 152/// \param AccessTy The access type of the pointer. 153/// \param AtLeastAtomic Are we looking for at-least an atomic load/store ? In 154/// case it is false, we can return an atomic or non-atomic load or store. In 155/// case it is true, we need to return an atomic load or store. 156/// \param ScanBB The basic block to scan. 157/// \param [in,out] ScanFrom The location to start scanning from. When this 158/// function returns, it points at the last instruction scanned. 159/// \param MaxInstsToScan The maximum number of instructions to scan. If this 160/// is zero, the whole block will be scanned. 161/// \param AA Optional pointer to alias analysis, to make the scan more 162/// precise. 163/// \param [out] IsLoadCSE Whether the returned value is a load from the same 164/// location in memory, as opposed to the value operand of a store. 165/// 166/// \returns The found value, or nullptr if no value is found. 167Value *findAvailablePtrLoadStore(const MemoryLocation &Loc, Type *AccessTy, 168 bool AtLeastAtomic, BasicBlock *ScanBB, 169 BasicBlock::iterator &ScanFrom, 170 unsigned MaxInstsToScan, AAResults *AA, 171 bool *IsLoadCSE, unsigned *NumScanedInst); 172 173/// Returns true if a pointer value \p A can be replace with another pointer 174/// value \B if they are deemed equal through some means (e.g. information from 175/// conditions). 176/// NOTE: the current implementations is incomplete and unsound. It does not 177/// reject all invalid cases yet, but will be made stricter in the future. In 178/// particular this means returning true means unknown if replacement is safe. 179bool canReplacePointersIfEqual(Value *A, Value *B, const DataLayout &DL, 180 Instruction *CtxI); 181} 182 183#endif 184