[llvm] 483fc73 - [Loads] Add overload for isDerefAndAlignedInLoop that takes SCEVs.(NFC)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Sun Mar 8 14:41:26 PDT 2026
Author: Florian Hahn
Date: 2026-03-08T21:38:53Z
New Revision: 483fc738ff106e22877cf3a1b0ca01ae5cac29ec
URL: https://github.com/llvm/llvm-project/commit/483fc738ff106e22877cf3a1b0ca01ae5cac29ec
DIFF: https://github.com/llvm/llvm-project/commit/483fc738ff106e22877cf3a1b0ca01ae5cac29ec.diff
LOG: [Loads] Add overload for isDerefAndAlignedInLoop that takes SCEVs.(NFC)
Add an overload of isDereferenceableAndAlignedInLoop that directly takes
the pointer and element sizes as SCEVs. This allows using it from
contexts without relying on an underlying load instruction in follow-up
patches.
Added:
Modified:
llvm/include/llvm/Analysis/Loads.h
llvm/include/llvm/Analysis/LoopAccessAnalysis.h
llvm/lib/Analysis/Loads.cpp
llvm/lib/Analysis/LoopAccessAnalysis.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/Loads.h b/llvm/include/llvm/Analysis/Loads.h
index 4893c0c9934d2..a9cbd5173973a 100644
--- a/llvm/include/llvm/Analysis/Loads.h
+++ b/llvm/include/llvm/Analysis/Loads.h
@@ -29,6 +29,7 @@ class Instruction;
class LoadInst;
class Loop;
class MemoryLocation;
+class SCEV;
class ScalarEvolution;
class SCEVPredicate;
template <typename T> class SmallVectorImpl;
@@ -87,6 +88,13 @@ LLVM_ABI bool isDereferenceableAndAlignedInLoop(
AssumptionCache *AC = nullptr,
SmallVectorImpl<const SCEVPredicate *> *Predicates = nullptr);
+/// Overload for isDereferenceableAndAlignedInLoop taking the pointer and access
+/// size directly as SCEVs.
+LLVM_ABI bool isDereferenceableAndAlignedInLoop(
+ const SCEV *PtrSCEV, Align Alignment, const SCEV *EltSizeSCEV, Loop *L,
+ ScalarEvolution &SE, DominatorTree &DT, AssumptionCache *AC = nullptr,
+ SmallVectorImpl<const SCEVPredicate *> *Predicates = nullptr);
+
/// Returns true if the loop contains read-only memory accesses and doesn't
/// throw. Puts loads that may fault into \p NonDereferenceableAndAlignedLoads.
LLVM_ABI bool
diff --git a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
index e92847d4a99c0..ac0b454d33737 100644
--- a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
+++ b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
@@ -286,7 +286,7 @@ class MemoryDepChecker {
const Loop *getInnermostLoop() const { return InnermostLoop; }
- DenseMap<std::pair<const SCEV *, Type *>,
+ DenseMap<std::pair<const SCEV *, const SCEV *>,
std::pair<const SCEV *, const SCEV *>> &
getPointerBounds() {
return PointerBounds;
@@ -370,7 +370,7 @@ class MemoryDepChecker {
/// Mapping of SCEV expressions to their expanded pointer bounds (pair of
/// start and end pointer expressions).
- DenseMap<std::pair<const SCEV *, Type *>,
+ DenseMap<std::pair<const SCEV *, const SCEV *>,
std::pair<const SCEV *, const SCEV *>>
PointerBounds;
@@ -943,7 +943,14 @@ LLVM_ABI bool isConsecutiveAccess(Value *A, Value *B, const DataLayout &DL,
LLVM_ABI std::pair<const SCEV *, const SCEV *> getStartAndEndForAccess(
const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy, const SCEV *BTC,
const SCEV *MaxBTC, ScalarEvolution *SE,
- DenseMap<std::pair<const SCEV *, Type *>,
+ DenseMap<std::pair<const SCEV *, const SCEV *>,
+ std::pair<const SCEV *, const SCEV *>> *PointerBounds,
+ DominatorTree *DT, AssumptionCache *AC,
+ std::optional<ScalarEvolution::LoopGuards> &LoopGuards);
+LLVM_ABI std::pair<const SCEV *, const SCEV *> getStartAndEndForAccess(
+ const Loop *Lp, const SCEV *PtrExpr, const SCEV *EltSizeSCEV,
+ const SCEV *BTC, const SCEV *MaxBTC, ScalarEvolution *SE,
+ DenseMap<std::pair<const SCEV *, const SCEV *>,
std::pair<const SCEV *, const SCEV *>> *PointerBounds,
DominatorTree *DT, AssumptionCache *AC,
std::optional<ScalarEvolution::LoopGuards> &LoopGuards);
diff --git a/llvm/lib/Analysis/Loads.cpp b/llvm/lib/Analysis/Loads.cpp
index 96bf17e6cdac5..c481385022af1 100644
--- a/llvm/lib/Analysis/Loads.cpp
+++ b/llvm/lib/Analysis/Loads.cpp
@@ -289,9 +289,9 @@ static bool AreEquivalentAddressValues(const Value *A, const Value *B) {
bool llvm::isDereferenceableAndAlignedInLoop(
LoadInst *LI, Loop *L, ScalarEvolution &SE, DominatorTree &DT,
AssumptionCache *AC, SmallVectorImpl<const SCEVPredicate *> *Predicates) {
- const Align Alignment = LI->getAlign();
auto &DL = LI->getDataLayout();
Value *Ptr = LI->getPointerOperand();
+ const SCEV *PtrSCEV = SE.getSCEV(Ptr);
APInt EltSize(DL.getIndexTypeSizeInBits(Ptr->getType()),
DL.getTypeStoreSize(LI->getType()).getFixedValue());
@@ -299,11 +299,19 @@ bool llvm::isDereferenceableAndAlignedInLoop(
// access is safe within the loop w/o needing predication.
if (L->isLoopInvariant(Ptr))
return isDereferenceableAndAlignedPointer(
- Ptr, Alignment, EltSize, DL, &*L->getHeader()->getFirstNonPHIIt(), AC,
- &DT);
+ Ptr, LI->getAlign(), EltSize, DL, &*L->getHeader()->getFirstNonPHIIt(),
+ AC, &DT);
- const SCEV *PtrScev = SE.getSCEV(Ptr);
- auto *AddRec = dyn_cast<SCEVAddRecExpr>(PtrScev);
+ const SCEV *EltSizeSCEV = SE.getConstant(EltSize);
+ return isDereferenceableAndAlignedInLoop(PtrSCEV, LI->getAlign(), EltSizeSCEV,
+ L, SE, DT, AC, Predicates);
+}
+
+bool llvm::isDereferenceableAndAlignedInLoop(
+ const SCEV *PtrSCEV, Align Alignment, const SCEV *EltSizeSCEV, Loop *L,
+ ScalarEvolution &SE, DominatorTree &DT, AssumptionCache *AC,
+ SmallVectorImpl<const SCEVPredicate *> *Predicates) {
+ auto *AddRec = dyn_cast<SCEVAddRecExpr>(PtrSCEV);
// Check to see if we have a repeating access pattern and it's possible
// to prove all accesses are well aligned.
@@ -314,6 +322,7 @@ bool llvm::isDereferenceableAndAlignedInLoop(
if (!Step)
return false;
+ const APInt &EltSize = cast<SCEVConstant>(EltSizeSCEV)->getAPInt();
// For the moment, restrict ourselves to the case where the access size is a
// multiple of the requested alignment and the base is aligned.
// TODO: generalize if a case found which warrants
@@ -333,9 +342,11 @@ bool llvm::isDereferenceableAndAlignedInLoop(
if (isa<SCEVCouldNotCompute>(MaxBECount))
return false;
std::optional<ScalarEvolution::LoopGuards> LoopGuards;
+
+ auto &DL = L->getHeader()->getDataLayout();
const auto &[AccessStart, AccessEnd] =
- getStartAndEndForAccess(L, PtrScev, LI->getType(), BECount, MaxBECount,
- &SE, nullptr, &DT, AC, LoopGuards);
+ getStartAndEndForAccess(L, PtrSCEV, EltSizeSCEV, BECount, MaxBECount, &SE,
+ nullptr, &DT, AC, LoopGuards);
if (isa<SCEVCouldNotCompute>(AccessStart) ||
isa<SCEVCouldNotCompute>(AccessEnd))
return false;
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index 8edaca6df33ac..50ad35a30ea84 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -318,14 +318,30 @@ static bool evaluatePtrAddRecAtMaxBTCWillNotWrap(
std::pair<const SCEV *, const SCEV *> llvm::getStartAndEndForAccess(
const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy, const SCEV *BTC,
const SCEV *MaxBTC, ScalarEvolution *SE,
- DenseMap<std::pair<const SCEV *, Type *>,
+ DenseMap<std::pair<const SCEV *, const SCEV *>,
+ std::pair<const SCEV *, const SCEV *>> *PointerBounds,
+ DominatorTree *DT, AssumptionCache *AC,
+ std::optional<ScalarEvolution::LoopGuards> &LoopGuards) {
+ auto &DL = Lp->getHeader()->getDataLayout();
+ Type *IdxTy = DL.getIndexType(PtrExpr->getType());
+ const SCEV *EltSizeSCEV = SE->getStoreSizeOfExpr(IdxTy, AccessTy);
+
+ // Delegate to the SCEV-based overload, passing through the cache.
+ return getStartAndEndForAccess(Lp, PtrExpr, EltSizeSCEV, BTC, MaxBTC, SE,
+ PointerBounds, DT, AC, LoopGuards);
+}
+
+std::pair<const SCEV *, const SCEV *> llvm::getStartAndEndForAccess(
+ const Loop *Lp, const SCEV *PtrExpr, const SCEV *EltSizeSCEV,
+ const SCEV *BTC, const SCEV *MaxBTC, ScalarEvolution *SE,
+ DenseMap<std::pair<const SCEV *, const SCEV *>,
std::pair<const SCEV *, const SCEV *>> *PointerBounds,
DominatorTree *DT, AssumptionCache *AC,
std::optional<ScalarEvolution::LoopGuards> &LoopGuards) {
std::pair<const SCEV *, const SCEV *> *PtrBoundsPair;
if (PointerBounds) {
auto [Iter, Ins] = PointerBounds->insert(
- {{PtrExpr, AccessTy},
+ {{PtrExpr, EltSizeSCEV},
{SE->getCouldNotCompute(), SE->getCouldNotCompute()}});
if (!Ins)
return Iter->second;
@@ -336,8 +352,6 @@ std::pair<const SCEV *, const SCEV *> llvm::getStartAndEndForAccess(
const SCEV *ScEnd;
auto &DL = Lp->getHeader()->getDataLayout();
- Type *IdxTy = DL.getIndexType(PtrExpr->getType());
- const SCEV *EltSizeSCEV = SE->getStoreSizeOfExpr(IdxTy, AccessTy);
if (SE->isLoopInvariant(PtrExpr, Lp)) {
ScStart = ScEnd = PtrExpr;
} else if (auto *AR = dyn_cast<SCEVAddRecExpr>(PtrExpr)) {
More information about the llvm-commits
mailing list