[llvm] 17b4e5d - [BasicAA] Don't pass through AA metadata (NFCI)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Sat Apr 3 02:31:51 PDT 2021
Author: Nikita Popov
Date: 2021-04-03T11:21:50+02:00
New Revision: 17b4e5d4563104130575c6e07e7a8f05a6f7653c
URL: https://github.com/llvm/llvm-project/commit/17b4e5d4563104130575c6e07e7a8f05a6f7653c
DIFF: https://github.com/llvm/llvm-project/commit/17b4e5d4563104130575c6e07e7a8f05a6f7653c.diff
LOG: [BasicAA] Don't pass through AA metadata (NFCI)
BasicAA itself doesn't make use of AA metadata, but passes it
through to recursive queries and makes it part of the cache key.
Aliasing decisions that are based on AA metadata (i.e. TBAA and
ScopedAA) are based *only* on AA metadata, so checking them with
different pointer values or sizes is not useful, the result will
always be the same.
While this change is a mild compile-time improvement by itself,
the actual goal here is to reduce the size of AA cache keys in
a followup change.
Differential Revision: https://reviews.llvm.org/D90098
Added:
Modified:
llvm/include/llvm/Analysis/BasicAliasAnalysis.h
llvm/lib/Analysis/BasicAliasAnalysis.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h
index f13cf0c313c1f..1468ad89c333f 100644
--- a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h
+++ b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h
@@ -208,29 +208,23 @@ class BasicAAResult : public AAResultBase<BasicAAResult> {
const SmallVectorImpl<VariableGEPIndex> &Src);
AliasResult aliasGEP(const GEPOperator *V1, LocationSize V1Size,
- const AAMDNodes &V1AAInfo, const Value *V2,
- LocationSize V2Size, const AAMDNodes &V2AAInfo,
+ const Value *V2, LocationSize V2Size,
const Value *UnderlyingV1, const Value *UnderlyingV2,
AAQueryInfo &AAQI);
AliasResult aliasPHI(const PHINode *PN, LocationSize PNSize,
- const AAMDNodes &PNAAInfo, const Value *V2,
- LocationSize V2Size, const AAMDNodes &V2AAInfo,
- AAQueryInfo &AAQI);
+ const Value *V2, LocationSize V2Size, AAQueryInfo &AAQI);
AliasResult aliasSelect(const SelectInst *SI, LocationSize SISize,
- const AAMDNodes &SIAAInfo, const Value *V2,
- LocationSize V2Size, const AAMDNodes &V2AAInfo,
+ const Value *V2, LocationSize V2Size,
AAQueryInfo &AAQI);
AliasResult aliasCheck(const Value *V1, LocationSize V1Size,
- const AAMDNodes &V1AATag, const Value *V2,
- LocationSize V2Size, const AAMDNodes &V2AATag,
+ const Value *V2, LocationSize V2Size,
AAQueryInfo &AAQI);
AliasResult aliasCheckRecursive(const Value *V1, LocationSize V1Size,
- const AAMDNodes &V1AATag, const Value *V2,
- LocationSize V2Size, const AAMDNodes &V2AATag,
+ const Value *V2, LocationSize V2Size,
AAQueryInfo &AAQI, const Value *O1,
const Value *O2);
};
diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
index 15e4946eb8fdd..5b5b85886d028 100644
--- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -783,8 +783,7 @@ AliasResult BasicAAResult::alias(const MemoryLocation &LocA,
AAQueryInfo &AAQI) {
assert(notDifferentParent(LocA.Ptr, LocB.Ptr) &&
"BasicAliasAnalysis doesn't support interprocedural queries.");
- return aliasCheck(LocA.Ptr, LocA.Size, LocA.AATags, LocB.Ptr, LocB.Size,
- LocB.AATags, AAQI);
+ return aliasCheck(LocA.Ptr, LocA.Size, LocB.Ptr, LocB.Size, AAQI);
}
/// Checks to see if the specified callsite can clobber the specified memory
@@ -1009,8 +1008,8 @@ static bool isBaseOfObject(const Value *V) {
/// UnderlyingV1 is getUnderlyingObject(GEP1), UnderlyingV2 is the same for
/// V2.
AliasResult BasicAAResult::aliasGEP(
- const GEPOperator *GEP1, LocationSize V1Size, const AAMDNodes &V1AAInfo,
- const Value *V2, LocationSize V2Size, const AAMDNodes &V2AAInfo,
+ const GEPOperator *GEP1, LocationSize V1Size,
+ const Value *V2, LocationSize V2Size,
const Value *UnderlyingV1, const Value *UnderlyingV2, AAQueryInfo &AAQI) {
if (!V1Size.hasValue() && !V2Size.hasValue()) {
// TODO: This limitation exists for compile-time reasons. Relax it if we
@@ -1063,8 +1062,8 @@ AliasResult BasicAAResult::aliasGEP(
// when performing the alias check on the underlying objects.
if (DecompGEP1.Offset == 0 && DecompGEP1.VarIndices.empty())
return getBestAAResults().alias(
- MemoryLocation(UnderlyingV1, V1Size, V1AAInfo),
- MemoryLocation(UnderlyingV2, V2Size, V2AAInfo), AAQI);
+ MemoryLocation(UnderlyingV1, V1Size),
+ MemoryLocation(UnderlyingV2, V2Size), AAQI);
// Do the base pointers alias?
AliasResult BaseAlias = getBestAAResults().alias(
@@ -1247,44 +1246,41 @@ static AliasResult MergeAliasResults(AliasResult A, AliasResult B) {
/// against another.
AliasResult
BasicAAResult::aliasSelect(const SelectInst *SI, LocationSize SISize,
- const AAMDNodes &SIAAInfo, const Value *V2,
- LocationSize V2Size, const AAMDNodes &V2AAInfo,
+ const Value *V2, LocationSize V2Size,
AAQueryInfo &AAQI) {
// 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 (SI->getCondition() == SI2->getCondition()) {
AliasResult Alias = getBestAAResults().alias(
- MemoryLocation(SI->getTrueValue(), SISize, SIAAInfo),
- MemoryLocation(SI2->getTrueValue(), V2Size, V2AAInfo), AAQI);
+ MemoryLocation(SI->getTrueValue(), SISize),
+ MemoryLocation(SI2->getTrueValue(), V2Size), AAQI);
if (Alias == MayAlias)
return MayAlias;
AliasResult ThisAlias = getBestAAResults().alias(
- MemoryLocation(SI->getFalseValue(), SISize, SIAAInfo),
- MemoryLocation(SI2->getFalseValue(), V2Size, V2AAInfo), AAQI);
+ MemoryLocation(SI->getFalseValue(), SISize),
+ MemoryLocation(SI2->getFalseValue(), V2Size), AAQI);
return MergeAliasResults(ThisAlias, Alias);
}
// If both arms of the Select node NoAlias or MustAlias V2, then returns
// NoAlias / MustAlias. Otherwise, returns MayAlias.
AliasResult Alias = getBestAAResults().alias(
- MemoryLocation(V2, V2Size, V2AAInfo),
- MemoryLocation(SI->getTrueValue(), SISize, SIAAInfo), AAQI);
+ MemoryLocation(V2, V2Size),
+ MemoryLocation(SI->getTrueValue(), SISize), AAQI);
if (Alias == MayAlias)
return MayAlias;
AliasResult ThisAlias = getBestAAResults().alias(
- MemoryLocation(V2, V2Size, V2AAInfo),
- MemoryLocation(SI->getFalseValue(), SISize, SIAAInfo), AAQI);
+ MemoryLocation(V2, V2Size),
+ MemoryLocation(SI->getFalseValue(), SISize), AAQI);
return MergeAliasResults(ThisAlias, Alias);
}
/// Provide a bunch of ad-hoc rules to disambiguate a PHI instruction against
/// another.
AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize,
- const AAMDNodes &PNAAInfo, const Value *V2,
- LocationSize V2Size,
- const AAMDNodes &V2AAInfo,
+ const Value *V2, LocationSize V2Size,
AAQueryInfo &AAQI) {
// If the values are PHIs in the same block, we can do a more precise
// as well as efficient check: just check for aliases between the values
@@ -1294,10 +1290,9 @@ AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize,
Optional<AliasResult> Alias;
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
AliasResult ThisAlias = getBestAAResults().alias(
- MemoryLocation(PN->getIncomingValue(i), PNSize, PNAAInfo),
+ MemoryLocation(PN->getIncomingValue(i), PNSize),
MemoryLocation(
- PN2->getIncomingValueForBlock(PN->getIncomingBlock(i)), V2Size,
- V2AAInfo),
+ PN2->getIncomingValueForBlock(PN->getIncomingBlock(i)), V2Size),
AAQI);
if (Alias)
*Alias = MergeAliasResults(*Alias, ThisAlias);
@@ -1398,8 +1393,8 @@ AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize,
AAQueryInfo *UseAAQI = BlockInserted ? &NewAAQI : &AAQI;
AliasResult Alias = getBestAAResults().alias(
- MemoryLocation(V2, V2Size, V2AAInfo),
- MemoryLocation(V1Srcs[0], PNSize, PNAAInfo), *UseAAQI);
+ MemoryLocation(V2, V2Size),
+ MemoryLocation(V1Srcs[0], PNSize), *UseAAQI);
// Early exit if the check of the first PHI source against V2 is MayAlias.
// Other results are not possible.
@@ -1416,8 +1411,7 @@ AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize,
Value *V = V1Srcs[i];
AliasResult ThisAlias = getBestAAResults().alias(
- MemoryLocation(V2, V2Size, V2AAInfo),
- MemoryLocation(V, PNSize, PNAAInfo), *UseAAQI);
+ MemoryLocation(V2, V2Size), MemoryLocation(V, PNSize), *UseAAQI);
Alias = MergeAliasResults(ThisAlias, Alias);
if (Alias == MayAlias)
break;
@@ -1429,9 +1423,7 @@ AliasResult BasicAAResult::aliasPHI(const PHINode *PN, LocationSize PNSize,
/// Provides a bunch of ad-hoc rules to disambiguate in common cases, such as
/// array references.
AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
- const AAMDNodes &V1AAInfo,
const Value *V2, LocationSize V2Size,
- const AAMDNodes &V2AAInfo,
AAQueryInfo &AAQI) {
// If either of the memory references is empty, it doesn't matter what the
// pointer values are.
@@ -1537,8 +1529,8 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
// Check the cache before climbing up use-def chains. This also terminates
// otherwise infinitely recursive queries.
- AAQueryInfo::LocPair Locs(MemoryLocation(V1, V1Size, V1AAInfo),
- MemoryLocation(V2, V2Size, V2AAInfo));
+ AAQueryInfo::LocPair Locs(MemoryLocation(V1, V1Size),
+ MemoryLocation(V2, V2Size));
if (V1 > V2)
std::swap(Locs.first, Locs.second);
const auto &Pair = AAQI.AliasCache.try_emplace(
@@ -1555,8 +1547,8 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
int OrigNumAssumptionUses = AAQI.NumAssumptionUses;
unsigned OrigNumAssumptionBasedResults = AAQI.AssumptionBasedResults.size();
- AliasResult Result = aliasCheckRecursive(V1, V1Size, V1AAInfo, V2, V2Size,
- V2AAInfo, AAQI, O1, O2);
+ AliasResult Result =
+ aliasCheckRecursive(V1, V1Size, V2, V2Size, AAQI, O1, O2);
auto It = AAQI.AliasCache.find(Locs);
assert(It != AAQI.AliasCache.end() && "Must be in cache");
@@ -1587,41 +1579,35 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
}
AliasResult BasicAAResult::aliasCheckRecursive(
- const Value *V1, LocationSize V1Size, const AAMDNodes &V1AAInfo,
- const Value *V2, LocationSize V2Size, const AAMDNodes &V2AAInfo,
+ const Value *V1, LocationSize V1Size,
+ const Value *V2, LocationSize V2Size,
AAQueryInfo &AAQI, const Value *O1, const Value *O2) {
if (const GEPOperator *GV1 = dyn_cast<GEPOperator>(V1)) {
- AliasResult Result =
- aliasGEP(GV1, V1Size, V1AAInfo, V2, V2Size, V2AAInfo, O1, O2, AAQI);
+ AliasResult Result = aliasGEP(GV1, V1Size, V2, V2Size, O1, O2, AAQI);
if (Result != MayAlias)
return Result;
} else if (const GEPOperator *GV2 = dyn_cast<GEPOperator>(V2)) {
- AliasResult Result =
- aliasGEP(GV2, V2Size, V2AAInfo, V1, V1Size, V1AAInfo, O2, O1, AAQI);
+ AliasResult Result = aliasGEP(GV2, V2Size, V1, V1Size, O2, O1, AAQI);
if (Result != MayAlias)
return Result;
}
if (const PHINode *PN = dyn_cast<PHINode>(V1)) {
- AliasResult Result =
- aliasPHI(PN, V1Size, V1AAInfo, V2, V2Size, V2AAInfo, AAQI);
+ AliasResult Result = aliasPHI(PN, V1Size, V2, V2Size, AAQI);
if (Result != MayAlias)
return Result;
} else if (const PHINode *PN = dyn_cast<PHINode>(V2)) {
- AliasResult Result =
- aliasPHI(PN, V2Size, V2AAInfo, V1, V1Size, V1AAInfo, AAQI);
+ AliasResult Result = aliasPHI(PN, V2Size, V1, V1Size, AAQI);
if (Result != MayAlias)
return Result;
}
if (const SelectInst *S1 = dyn_cast<SelectInst>(V1)) {
- AliasResult Result =
- aliasSelect(S1, V1Size, V1AAInfo, V2, V2Size, V2AAInfo, AAQI);
+ AliasResult Result = aliasSelect(S1, V1Size, V2, V2Size, AAQI);
if (Result != MayAlias)
return Result;
} else if (const SelectInst *S2 = dyn_cast<SelectInst>(V2)) {
- AliasResult Result =
- aliasSelect(S2, V2Size, V2AAInfo, V1, V1Size, V1AAInfo, AAQI);
+ AliasResult Result = aliasSelect(S2, V2Size, V1, V1Size, AAQI);
if (Result != MayAlias)
return Result;
}
More information about the llvm-commits
mailing list