[llvm] 9a09c73 - [BasicAA] Make isNotCapturedBeforeOrAt() check for calls more precise (#69931)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Nov 21 00:28:13 PST 2023
Author: Nikita Popov
Date: 2023-11-21T09:28:08+01:00
New Revision: 9a09c737a052dc0e2b8c15a969d16cff7ea0c133
URL: https://github.com/llvm/llvm-project/commit/9a09c737a052dc0e2b8c15a969d16cff7ea0c133
DIFF: https://github.com/llvm/llvm-project/commit/9a09c737a052dc0e2b8c15a969d16cff7ea0c133.diff
LOG: [BasicAA] Make isNotCapturedBeforeOrAt() check for calls more precise (#69931)
For calls, we are only interested in captures before the call, not
captures by the call itself -- arguments that get passed to the call are
checked explicitly.
In particular, the current implementation is not optimal if the pointer
is captured via a readonly argument -- in that case, we know that even
if the argument is captured, the call will not modify the argument (at
least not via that argument).
Make this more precise by renaming to isCapturedBefore() and adding an
OrAt argument that allows us to toggle whether to consider captures in
the instruction itself or not.
Added:
Modified:
llvm/include/llvm/Analysis/AliasAnalysis.h
llvm/lib/Analysis/BasicAliasAnalysis.cpp
llvm/test/Transforms/GVN/captured-before.ll
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/AliasAnalysis.h b/llvm/include/llvm/Analysis/AliasAnalysis.h
index 0d0e94a89976a79..081783e243678cc 100644
--- a/llvm/include/llvm/Analysis/AliasAnalysis.h
+++ b/llvm/include/llvm/Analysis/AliasAnalysis.h
@@ -152,8 +152,11 @@ raw_ostream &operator<<(raw_ostream &OS, AliasResult AR);
/// Virtual base class for providers of capture information.
struct CaptureInfo {
virtual ~CaptureInfo() = 0;
- virtual bool isNotCapturedBeforeOrAt(const Value *Object,
- const Instruction *I) = 0;
+
+ /// Check whether Object is not captured before instruction I. If OrAt is
+ /// true, captures by instruction I itself are also considered.
+ virtual bool isNotCapturedBefore(const Value *Object, const Instruction *I,
+ bool OrAt) = 0;
};
/// Context-free CaptureInfo provider, which computes and caches whether an
@@ -163,8 +166,8 @@ class SimpleCaptureInfo final : public CaptureInfo {
SmallDenseMap<const Value *, bool, 8> IsCapturedCache;
public:
- bool isNotCapturedBeforeOrAt(const Value *Object,
- const Instruction *I) override;
+ bool isNotCapturedBefore(const Value *Object, const Instruction *I,
+ bool OrAt) override;
};
/// Context-sensitive CaptureInfo provider, which computes and caches the
@@ -188,8 +191,8 @@ class EarliestEscapeInfo final : public CaptureInfo {
EarliestEscapeInfo(DominatorTree &DT, const LoopInfo *LI = nullptr)
: DT(DT), LI(LI) {}
- bool isNotCapturedBeforeOrAt(const Value *Object,
- const Instruction *I) override;
+ bool isNotCapturedBefore(const Value *Object, const Instruction *I,
+ bool OrAt) override;
void removeInstruction(Instruction *I);
};
diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
index a369ebe82320a15..476028bd91b23cd 100644
--- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -194,13 +194,21 @@ static bool isObjectSize(const Value *V, TypeSize Size, const DataLayout &DL,
CaptureInfo::~CaptureInfo() = default;
-bool SimpleCaptureInfo::isNotCapturedBeforeOrAt(const Value *Object,
- const Instruction *I) {
+bool SimpleCaptureInfo::isNotCapturedBefore(const Value *Object,
+ const Instruction *I, bool OrAt) {
return isNonEscapingLocalObject(Object, &IsCapturedCache);
}
-bool EarliestEscapeInfo::isNotCapturedBeforeOrAt(const Value *Object,
- const Instruction *I) {
+static bool isNotInCycle(const Instruction *I, const DominatorTree &DT,
+ const LoopInfo *LI) {
+ BasicBlock *BB = const_cast<BasicBlock *>(I->getParent());
+ SmallVector<BasicBlock *> Succs(successors(BB));
+ return Succs.empty() ||
+ !isPotentiallyReachableFromMany(Succs, BB, nullptr, &DT, LI);
+}
+
+bool EarliestEscapeInfo::isNotCapturedBefore(const Value *Object,
+ const Instruction *I, bool OrAt) {
if (!isIdentifiedFunctionLocal(Object))
return false;
@@ -220,8 +228,13 @@ bool EarliestEscapeInfo::isNotCapturedBeforeOrAt(const Value *Object,
if (!Iter.first->second)
return true;
- return I != Iter.first->second &&
- !isPotentiallyReachable(Iter.first->second, I, nullptr, &DT, LI);
+ if (I == Iter.first->second) {
+ if (OrAt)
+ return false;
+ return isNotInCycle(I, DT, LI);
+ }
+
+ return !isPotentiallyReachable(Iter.first->second, I, nullptr, &DT, LI);
}
void EarliestEscapeInfo::removeInstruction(Instruction *I) {
@@ -887,7 +900,7 @@ ModRefInfo BasicAAResult::getModRefInfo(const CallBase *Call,
// Make sure the object has not escaped here, and then check that none of the
// call arguments alias the object below.
if (!isa<Constant>(Object) && Call != Object &&
- AAQI.CI->isNotCapturedBeforeOrAt(Object, Call)) {
+ AAQI.CI->isNotCapturedBefore(Object, Call, /*OrAt*/ false)) {
// Optimistically assume that call doesn't touch Object and check this
// assumption in the following loop.
@@ -1512,10 +1525,10 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
// location if that memory location doesn't escape. Or it may pass a
// nocapture value to other functions as long as they don't capture it.
if (isEscapeSource(O1) &&
- AAQI.CI->isNotCapturedBeforeOrAt(O2, cast<Instruction>(O1)))
+ AAQI.CI->isNotCapturedBefore(O2, cast<Instruction>(O1), /*OrAt*/ true))
return AliasResult::NoAlias;
if (isEscapeSource(O2) &&
- AAQI.CI->isNotCapturedBeforeOrAt(O1, cast<Instruction>(O2)))
+ AAQI.CI->isNotCapturedBefore(O1, cast<Instruction>(O2), /*OrAt*/ true))
return AliasResult::NoAlias;
}
@@ -1708,12 +1721,7 @@ bool BasicAAResult::isValueEqualInPotentialCycles(const Value *V,
if (!Inst || Inst->getParent()->isEntryBlock())
return true;
- // Check whether the instruction is part of a cycle, by checking whether the
- // block can (non-trivially) reach itself.
- BasicBlock *BB = const_cast<BasicBlock *>(Inst->getParent());
- SmallVector<BasicBlock *> Succs(successors(BB));
- return !Succs.empty() &&
- !isPotentiallyReachableFromMany(Succs, BB, nullptr, DT);
+ return isNotInCycle(Inst, *DT, /*LI*/ nullptr);
}
/// Computes the symbolic
diff erence between two de-composed GEPs.
diff --git a/llvm/test/Transforms/GVN/captured-before.ll b/llvm/test/Transforms/GVN/captured-before.ll
index 6bf95de9ee0b5f4..62529b8c1cf62db 100644
--- a/llvm/test/Transforms/GVN/captured-before.ll
+++ b/llvm/test/Transforms/GVN/captured-before.ll
@@ -83,8 +83,7 @@ define i32 @test_capture_readonly() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 123, ptr [[A]], align 4
; CHECK-NEXT: call void @capture(ptr readonly [[A]])
-; CHECK-NEXT: [[V:%.*]] = load i32, ptr [[A]], align 4
-; CHECK-NEXT: ret i32 [[V]]
+; CHECK-NEXT: ret i32 123
;
%a = alloca i32
store i32 123, ptr %a
More information about the llvm-commits
mailing list