aboutsummaryrefslogtreecommitdiff
path: root/llvm/lib/Analysis/AliasAnalysis.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/Analysis/AliasAnalysis.cpp')
-rw-r--r--llvm/lib/Analysis/AliasAnalysis.cpp85
1 files changed, 56 insertions, 29 deletions
diff --git a/llvm/lib/Analysis/AliasAnalysis.cpp b/llvm/lib/Analysis/AliasAnalysis.cpp
index fae7a84332fd..e7445e225d52 100644
--- a/llvm/lib/Analysis/AliasAnalysis.cpp
+++ b/llvm/lib/Analysis/AliasAnalysis.cpp
@@ -63,9 +63,18 @@ STATISTIC(NumNoAlias, "Number of NoAlias results");
STATISTIC(NumMayAlias, "Number of MayAlias results");
STATISTIC(NumMustAlias, "Number of MustAlias results");
+namespace llvm {
/// Allow disabling BasicAA from the AA results. This is particularly useful
/// when testing to isolate a single AA implementation.
cl::opt<bool> DisableBasicAA("disable-basic-aa", cl::Hidden, cl::init(false));
+} // namespace llvm
+
+#ifndef NDEBUG
+/// Print a trace of alias analysis queries and their results.
+static cl::opt<bool> EnableAATrace("aa-trace", cl::Hidden, cl::init(false));
+#else
+static const bool EnableAATrace = false;
+#endif
AAResults::AAResults(AAResults &&Arg)
: TLI(Arg.TLI), AAs(std::move(Arg.AAs)), AADeps(std::move(Arg.AADeps)) {
@@ -116,20 +125,34 @@ AliasResult AAResults::alias(const MemoryLocation &LocA,
AliasResult AAResults::alias(const MemoryLocation &LocA,
const MemoryLocation &LocB, AAQueryInfo &AAQI) {
- AliasResult Result = MayAlias;
+ AliasResult Result = AliasResult::MayAlias;
+
+ if (EnableAATrace) {
+ for (unsigned I = 0; I < AAQI.Depth; ++I)
+ dbgs() << " ";
+ dbgs() << "Start " << *LocA.Ptr << " @ " << LocA.Size << ", "
+ << *LocB.Ptr << " @ " << LocB.Size << "\n";
+ }
- Depth++;
+ AAQI.Depth++;
for (const auto &AA : AAs) {
Result = AA->alias(LocA, LocB, AAQI);
- if (Result != MayAlias)
+ if (Result != AliasResult::MayAlias)
break;
}
- Depth--;
+ AAQI.Depth--;
+
+ if (EnableAATrace) {
+ for (unsigned I = 0; I < AAQI.Depth; ++I)
+ dbgs() << " ";
+ dbgs() << "End " << *LocA.Ptr << " @ " << LocA.Size << ", "
+ << *LocB.Ptr << " @ " << LocB.Size << " = " << Result << "\n";
+ }
- if (Depth == 0) {
- if (Result == NoAlias)
+ if (AAQI.Depth == 0) {
+ if (Result == AliasResult::NoAlias)
++NumNoAlias;
- else if (Result == MustAlias)
+ else if (Result == AliasResult::MustAlias)
++NumMustAlias;
else
++NumMayAlias;
@@ -235,12 +258,12 @@ ModRefInfo AAResults::getModRefInfo(const CallBase *Call,
MemoryLocation ArgLoc =
MemoryLocation::getForArgument(Call, ArgIdx, TLI);
AliasResult ArgAlias = alias(ArgLoc, Loc, AAQI);
- if (ArgAlias != NoAlias) {
+ if (ArgAlias != AliasResult::NoAlias) {
ModRefInfo ArgMask = getArgModRefInfo(Call, ArgIdx);
AllArgsMask = unionModRef(AllArgsMask, ArgMask);
}
// Conservatively clear IsMustAlias unless only MustAlias is found.
- IsMustAlias &= (ArgAlias == MustAlias);
+ IsMustAlias &= (ArgAlias == AliasResult::MustAlias);
}
}
// Return NoModRef if no alias found with any argument.
@@ -428,17 +451,19 @@ FunctionModRefBehavior AAResults::getModRefBehavior(const Function *F) {
raw_ostream &llvm::operator<<(raw_ostream &OS, AliasResult AR) {
switch (AR) {
- case NoAlias:
+ case AliasResult::NoAlias:
OS << "NoAlias";
break;
- case MustAlias:
+ case AliasResult::MustAlias:
OS << "MustAlias";
break;
- case MayAlias:
+ case AliasResult::MayAlias:
OS << "MayAlias";
break;
- case PartialAlias:
+ case AliasResult::PartialAlias:
OS << "PartialAlias";
+ if (AR.hasOffset())
+ OS << " (off " << AR.getOffset() << ")";
break;
}
return OS;
@@ -464,9 +489,9 @@ ModRefInfo AAResults::getModRefInfo(const LoadInst *L,
// or write the specified memory.
if (Loc.Ptr) {
AliasResult AR = alias(MemoryLocation::get(L), Loc, AAQI);
- if (AR == NoAlias)
+ if (AR == AliasResult::NoAlias)
return ModRefInfo::NoModRef;
- if (AR == MustAlias)
+ if (AR == AliasResult::MustAlias)
return ModRefInfo::MustRef;
}
// Otherwise, a load just reads.
@@ -489,7 +514,7 @@ ModRefInfo AAResults::getModRefInfo(const StoreInst *S,
AliasResult AR = alias(MemoryLocation::get(S), Loc, AAQI);
// If the store address cannot alias the pointer in question, then the
// specified memory cannot be modified by the store.
- if (AR == NoAlias)
+ if (AR == AliasResult::NoAlias)
return ModRefInfo::NoModRef;
// If the pointer is a pointer to constant memory, then it could not have
@@ -498,7 +523,7 @@ ModRefInfo AAResults::getModRefInfo(const StoreInst *S,
return ModRefInfo::NoModRef;
// If the store address aliases the pointer as must alias, set Must.
- if (AR == MustAlias)
+ if (AR == AliasResult::MustAlias)
return ModRefInfo::MustMod;
}
@@ -534,7 +559,7 @@ ModRefInfo AAResults::getModRefInfo(const VAArgInst *V,
AliasResult AR = alias(MemoryLocation::get(V), Loc, AAQI);
// If the va_arg address cannot alias the pointer in question, then the
// specified memory cannot be accessed by the va_arg.
- if (AR == NoAlias)
+ if (AR == AliasResult::NoAlias)
return ModRefInfo::NoModRef;
// If the pointer is a pointer to constant memory, then it could not have
@@ -543,7 +568,7 @@ ModRefInfo AAResults::getModRefInfo(const VAArgInst *V,
return ModRefInfo::NoModRef;
// If the va_arg aliases the pointer as must alias, set Must.
- if (AR == MustAlias)
+ if (AR == AliasResult::MustAlias)
return ModRefInfo::MustModRef;
}
@@ -608,11 +633,11 @@ ModRefInfo AAResults::getModRefInfo(const AtomicCmpXchgInst *CX,
AliasResult AR = alias(MemoryLocation::get(CX), Loc, AAQI);
// If the cmpxchg address does not alias the location, it does not access
// it.
- if (AR == NoAlias)
+ if (AR == AliasResult::NoAlias)
return ModRefInfo::NoModRef;
// If the cmpxchg address aliases the pointer as must alias, set Must.
- if (AR == MustAlias)
+ if (AR == AliasResult::MustAlias)
return ModRefInfo::MustModRef;
}
@@ -636,11 +661,11 @@ ModRefInfo AAResults::getModRefInfo(const AtomicRMWInst *RMW,
AliasResult AR = alias(MemoryLocation::get(RMW), Loc, AAQI);
// If the atomicrmw address does not alias the location, it does not access
// it.
- if (AR == NoAlias)
+ if (AR == AliasResult::NoAlias)
return ModRefInfo::NoModRef;
// If the atomicrmw address aliases the pointer as must alias, set Must.
- if (AR == MustAlias)
+ if (AR == AliasResult::MustAlias)
return ModRefInfo::MustModRef;
}
@@ -693,13 +718,13 @@ ModRefInfo AAResults::getModRefInfo(const Instruction *I,
/// with a smarter AA in place, this test is just wasting compile time.
ModRefInfo AAResults::callCapturesBefore(const Instruction *I,
const MemoryLocation &MemLoc,
- DominatorTree *DT) {
+ DominatorTree *DT,
+ AAQueryInfo &AAQI) {
if (!DT)
return ModRefInfo::ModRef;
const Value *Object = getUnderlyingObject(MemLoc.Ptr);
- if (!isIdentifiedObject(Object) || isa<GlobalValue>(Object) ||
- isa<Constant>(Object))
+ if (!isIdentifiedFunctionLocal(Object))
return ModRefInfo::ModRef;
const auto *Call = dyn_cast<CallBase>(I);
@@ -725,14 +750,16 @@ ModRefInfo AAResults::callCapturesBefore(const Instruction *I,
!Call->isByValArgument(ArgNo)))
continue;
- AliasResult AR = alias(*CI, Object);
+ AliasResult AR = alias(
+ MemoryLocation::getBeforeOrAfter(*CI),
+ MemoryLocation::getBeforeOrAfter(Object), AAQI);
// If this is a no-capture pointer argument, see if we can tell that it
// is impossible to alias the pointer we're checking. If not, we have to
// assume that the call could touch the pointer, even though it doesn't
// escape.
- if (AR != MustAlias)
+ if (AR != AliasResult::MustAlias)
IsMustAlias = false;
- if (AR == NoAlias)
+ if (AR == AliasResult::NoAlias)
continue;
if (Call->doesNotAccessMemory(ArgNo))
continue;
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-23 17:12:41 +0000