[llvm] b71bf08 - [AA] Move MayBeCrossIteration into AAQI (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Mon Nov 14 07:42:30 PST 2022
Author: Nikita Popov
Date: 2022-11-14T16:42:22+01:00
New Revision: b71bf080d01dbdc0c303974e80b376a188bfdf91
URL: https://github.com/llvm/llvm-project/commit/b71bf080d01dbdc0c303974e80b376a188bfdf91
DIFF: https://github.com/llvm/llvm-project/commit/b71bf080d01dbdc0c303974e80b376a188bfdf91.diff
LOG: [AA] Move MayBeCrossIteration into AAQI (NFC)
Move the MayBeCrossIteration flag from BasicAA into AAQI. This is
in preparation for exposing it to users of the AA API.
Added:
Modified:
llvm/include/llvm/Analysis/AliasAnalysis.h
llvm/include/llvm/Analysis/BasicAliasAnalysis.h
llvm/lib/Analysis/BasicAliasAnalysis.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/AliasAnalysis.h b/llvm/include/llvm/Analysis/AliasAnalysis.h
index 4d8e71d370ced..c50cb2d202118 100644
--- a/llvm/include/llvm/Analysis/AliasAnalysis.h
+++ b/llvm/include/llvm/Analysis/AliasAnalysis.h
@@ -262,6 +262,22 @@ class AAQueryInfo {
/// assumption is disproven.
SmallVector<AAQueryInfo::LocPair, 4> AssumptionBasedResults;
+ /// Tracks whether the accesses may be on
diff erent cycle iterations.
+ ///
+ /// When interpret "Value" pointer equality as value equality we need to make
+ /// sure that the "Value" is not part of a cycle. Otherwise, two uses could
+ /// come from
diff erent "iterations" of a cycle and see
diff erent values for
+ /// the same "Value" pointer.
+ ///
+ /// The following example shows the problem:
+ /// %p = phi(%alloca1, %addr2)
+ /// %l = load %ptr
+ /// %addr1 = gep, %alloca2, 0, %l
+ /// %addr2 = gep %alloca2, 0, (%l + 1)
+ /// alias(%p, %addr1) -> MayAlias !
+ /// store %l, ...
+ bool MayBeCrossIteration = false;
+
AAQueryInfo(AAResults &AAR, CaptureInfo *CI) : AAR(AAR), CI(CI) {}
};
diff --git a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h
index a2909f46e3ba2..4df09cb6aa07a 100644
--- a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h
+++ b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h
@@ -98,22 +98,6 @@ class BasicAAResult : public AAResultBase {
private:
struct DecomposedGEP;
- /// Tracks whether the accesses may be on
diff erent cycle iterations.
- ///
- /// When interpret "Value" pointer equality as value equality we need to make
- /// sure that the "Value" is not part of a cycle. Otherwise, two uses could
- /// come from
diff erent "iterations" of a cycle and see
diff erent values for
- /// the same "Value" pointer.
- ///
- /// The following example shows the problem:
- /// %p = phi(%alloca1, %addr2)
- /// %l = load %ptr
- /// %addr1 = gep, %alloca2, 0, %l
- /// %addr2 = gep %alloca2, 0, (%l + 1)
- /// alias(%p, %addr1) -> MayAlias !
- /// store %l, ...
- bool MayBeCrossIteration = false;
-
/// Tracks instructions visited by pointsToConstantMemory.
SmallPtrSet<const Value *, 16> Visited;
@@ -129,15 +113,16 @@ class BasicAAResult : public AAResultBase {
/// will therefore conservatively refuse to decompose these expressions.
/// However, we know that, for all %x, zext(%x) != zext(%x + 1), even if
/// the addition overflows.
- bool
- constantOffsetHeuristic(const DecomposedGEP &GEP, LocationSize V1Size,
- LocationSize V2Size, AssumptionCache *AC,
- DominatorTree *DT);
+ bool constantOffsetHeuristic(const DecomposedGEP &GEP, LocationSize V1Size,
+ LocationSize V2Size, AssumptionCache *AC,
+ DominatorTree *DT, const AAQueryInfo &AAQI);
- bool isValueEqualInPotentialCycles(const Value *V1, const Value *V2);
+ bool isValueEqualInPotentialCycles(const Value *V1, const Value *V2,
+ const AAQueryInfo &AAQI);
void subtractDecomposedGEPs(DecomposedGEP &DestGEP,
- const DecomposedGEP &SrcGEP);
+ const DecomposedGEP &SrcGEP,
+ const AAQueryInfo &AAQI);
AliasResult aliasGEP(const GEPOperator *V1, LocationSize V1Size,
const Value *V2, LocationSize V2Size,
diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
index 30dab43101dea..537d0c44ffc9b 100644
--- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -1038,7 +1038,7 @@ AliasResult BasicAAResult::aliasGEP(
// Subtract the GEP2 pointer from the GEP1 pointer to find out their
// symbolic
diff erence.
- subtractDecomposedGEPs(DecompGEP1, DecompGEP2);
+ subtractDecomposedGEPs(DecompGEP1, DecompGEP2, AAQI);
// If an inbounds GEP would have to start from an out of bounds address
// for the two to alias, then we can assume noalias.
@@ -1222,7 +1222,7 @@ AliasResult BasicAAResult::aliasGEP(
const VariableGEPIndex &Var0 = DecompGEP1.VarIndices[0];
const VariableGEPIndex &Var1 = DecompGEP1.VarIndices[1];
if (Var0.Scale == -Var1.Scale && Var0.Val.TruncBits == 0 &&
- Var0.Val.hasSameCastsAs(Var1.Val) && !MayBeCrossIteration &&
+ Var0.Val.hasSameCastsAs(Var1.Val) && !AAQI.MayBeCrossIteration &&
isKnownNonEqual(Var0.Val.V, Var1.Val.V, DL, &AC, /* CxtI */ nullptr,
DT))
MinAbsVarIndex = Var0.Scale.abs();
@@ -1238,7 +1238,7 @@ AliasResult BasicAAResult::aliasGEP(
return AliasResult::NoAlias;
}
- if (constantOffsetHeuristic(DecompGEP1, V1Size, V2Size, &AC, DT))
+ if (constantOffsetHeuristic(DecompGEP1, V1Size, V2Size, &AC, DT, AAQI))
return AliasResult::NoAlias;
// Statically, we can see that the base objects are the same, but the
@@ -1268,8 +1268,8 @@ BasicAAResult::aliasSelect(const SelectInst *SI, LocationSize SISize,
// If the values are Selects with the same condition, we can do a more precise
// check: just check for aliases between the values on corresponding arms.
if (const SelectInst *SI2 = dyn_cast<SelectInst>(V2))
- if (isValueEqualInPotentialCycles(SI->getCondition(),
- SI2->getCondition())) {
+ if (isValueEqualInPotentialCycles(SI->getCondition(), SI2->getCondition(),
+ AAQI)) {
AliasResult Alias =
AAQI.AAR.alias(MemoryLocation(SI->getTrueValue(), SISize),
MemoryLocation(SI2->getTrueValue(), V2Size), AAQI);
@@ -1398,7 +1398,7 @@ AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize,
// In the recursive alias queries below, we may compare values from two
//
diff erent loop iterations.
- SaveAndRestore<bool> SavedMayBeCrossIteration(MayBeCrossIteration, true);
+ SaveAndRestore<bool> SavedMayBeCrossIteration(AAQI.MayBeCrossIteration, true);
AliasResult Alias = AAQI.AAR.alias(MemoryLocation(V1Srcs[0], PNSize),
MemoryLocation(V2, V2Size), AAQI);
@@ -1452,7 +1452,7 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
// case. The function isValueEqualInPotentialCycles ensures that this cannot
// happen by looking at the visited phi nodes and making sure they cannot
// reach the value.
- if (isValueEqualInPotentialCycles(V1, V2))
+ if (isValueEqualInPotentialCycles(V1, V2, AAQI))
return AliasResult::MustAlias;
if (!V1->getType()->isPointerTy() || !V2->getType()->isPointerTy())
@@ -1538,8 +1538,8 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
// otherwise infinitely recursive queries. Include MayBeCrossIteration in the
// cache key, because some cases where MayBeCrossIteration==false returns
// MustAlias or NoAlias may become MayAlias under MayBeCrossIteration==true.
- AAQueryInfo::LocPair Locs({V1, V1Size, MayBeCrossIteration},
- {V2, V2Size, MayBeCrossIteration});
+ AAQueryInfo::LocPair Locs({V1, V1Size, AAQI.MayBeCrossIteration},
+ {V2, V2Size, AAQI.MayBeCrossIteration});
const bool Swapped = V1 > V2;
if (Swapped)
std::swap(Locs.first, Locs.second);
@@ -1652,11 +1652,12 @@ AliasResult BasicAAResult::aliasCheckRecursive(
/// are looking through phi nodes, that is we say
/// noalias(V, phi(VA, VB)) if noalias(V, VA) and noalias(V, VB).
bool BasicAAResult::isValueEqualInPotentialCycles(const Value *V,
- const Value *V2) {
+ const Value *V2,
+ const AAQueryInfo &AAQI) {
if (V != V2)
return false;
- if (!MayBeCrossIteration)
+ if (!AAQI.MayBeCrossIteration)
return true;
// Non-instructions and instructions in the entry block cannot be part of
@@ -1674,7 +1675,8 @@ bool BasicAAResult::isValueEqualInPotentialCycles(const Value *V,
/// Computes the symbolic
diff erence between two de-composed GEPs.
void BasicAAResult::subtractDecomposedGEPs(DecomposedGEP &DestGEP,
- const DecomposedGEP &SrcGEP) {
+ const DecomposedGEP &SrcGEP,
+ const AAQueryInfo &AAQI) {
DestGEP.Offset -= SrcGEP.Offset;
for (const VariableGEPIndex &Src : SrcGEP.VarIndices) {
// Find V in Dest. This is N^2, but pointer indices almost never have more
@@ -1682,7 +1684,7 @@ void BasicAAResult::subtractDecomposedGEPs(DecomposedGEP &DestGEP,
bool Found = false;
for (auto I : enumerate(DestGEP.VarIndices)) {
VariableGEPIndex &Dest = I.value();
- if (!isValueEqualInPotentialCycles(Dest.Val.V, Src.Val.V) ||
+ if (!isValueEqualInPotentialCycles(Dest.Val.V, Src.Val.V, AAQI) ||
!Dest.Val.hasSameCastsAs(Src.Val))
continue;
@@ -1706,9 +1708,12 @@ void BasicAAResult::subtractDecomposedGEPs(DecomposedGEP &DestGEP,
}
}
-bool BasicAAResult::constantOffsetHeuristic(
- const DecomposedGEP &GEP, LocationSize MaybeV1Size,
- LocationSize MaybeV2Size, AssumptionCache *AC, DominatorTree *DT) {
+bool BasicAAResult::constantOffsetHeuristic(const DecomposedGEP &GEP,
+ LocationSize MaybeV1Size,
+ LocationSize MaybeV2Size,
+ AssumptionCache *AC,
+ DominatorTree *DT,
+ const AAQueryInfo &AAQI) {
if (GEP.VarIndices.size() != 2 || !MaybeV1Size.hasValue() ||
!MaybeV2Size.hasValue())
return false;
@@ -1732,7 +1737,7 @@ bool BasicAAResult::constantOffsetHeuristic(
LinearExpression E1 =
GetLinearExpression(CastedValue(Var1.Val.V), DL, 0, AC, DT);
if (E0.Scale != E1.Scale || !E0.Val.hasSameCastsAs(E1.Val) ||
- !isValueEqualInPotentialCycles(E0.Val.V, E1.Val.V))
+ !isValueEqualInPotentialCycles(E0.Val.V, E1.Val.V, AAQI))
return false;
// We have a hit - Var0 and Var1 only
diff er by a constant offset!
More information about the llvm-commits
mailing list