[llvm] 9cbdcfc - [CaptureTracking] Remove StoreCaptures parameter (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Mon Feb 24 03:01:11 PST 2025
Author: Nikita Popov
Date: 2025-02-24T12:00:57+01:00
New Revision: 9cbdcfcafdc0646cef27c94ee22770b2d7aebf6a
URL: https://github.com/llvm/llvm-project/commit/9cbdcfcafdc0646cef27c94ee22770b2d7aebf6a
DIFF: https://github.com/llvm/llvm-project/commit/9cbdcfcafdc0646cef27c94ee22770b2d7aebf6a.diff
LOG: [CaptureTracking] Remove StoreCaptures parameter (NFC)
The implementation doesn't use it, and is unlikely to use it in
the future.
The places that do set StoreCaptures=false, do so incorrectly and
would be broken if the parameter actually did anything.
Added:
Modified:
llvm/include/llvm/Analysis/CaptureTracking.h
llvm/lib/Analysis/AliasAnalysis.cpp
llvm/lib/Analysis/BasicAliasAnalysis.cpp
llvm/lib/Analysis/CaptureTracking.cpp
llvm/lib/Transforms/IPO/FunctionAttrs.cpp
llvm/lib/Transforms/Instrumentation/SanitizerBinaryMetadata.cpp
llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
llvm/lib/Transforms/Scalar/LICM.cpp
llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
llvm/lib/Transforms/Utils/InlineFunction.cpp
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
llvm/unittests/Analysis/CaptureTrackingTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/CaptureTracking.h b/llvm/include/llvm/Analysis/CaptureTracking.h
index 06a00d9ae7899..ef69d40aac18a 100644
--- a/llvm/include/llvm/Analysis/CaptureTracking.h
+++ b/llvm/include/llvm/Analysis/CaptureTracking.h
@@ -35,14 +35,12 @@ namespace llvm {
/// by the enclosing function (which is required to exist). This routine can
/// be expensive, so consider caching the results. The boolean ReturnCaptures
/// specifies whether returning the value (or part of it) from the function
- /// counts as capturing it or not. The boolean StoreCaptures specified
- /// whether storing the value (or part of it) into memory anywhere
- /// automatically counts as capturing it or not.
+ /// counts as capturing it or not.
/// MaxUsesToExplore specifies how many uses the analysis should explore for
/// one value before giving up due too "too many uses". If MaxUsesToExplore
/// is zero, a default value is assumed.
bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures,
- bool StoreCaptures, unsigned MaxUsesToExplore = 0);
+ unsigned MaxUsesToExplore = 0);
/// PointerMayBeCapturedBefore - Return true if this pointer value may be
/// captured by the enclosing function (which is required to exist). If a
@@ -50,16 +48,13 @@ namespace llvm {
/// instruction are considered. This routine can be expensive, so consider
/// caching the results. The boolean ReturnCaptures specifies whether
/// returning the value (or part of it) from the function counts as capturing
- /// it or not. The boolean StoreCaptures specified whether storing the value
- /// (or part of it) into memory anywhere automatically counts as capturing it
- /// or not. Captures by the provided instruction are considered if the
+ /// it or not. Captures by the provided instruction are considered if the
/// final parameter is true.
/// MaxUsesToExplore specifies how many uses the analysis should explore for
/// one value before giving up due too "too many uses". If MaxUsesToExplore
/// is zero, a default value is assumed.
bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
- bool StoreCaptures, const Instruction *I,
- const DominatorTree *DT,
+ const Instruction *I, const DominatorTree *DT,
bool IncludeI = false,
unsigned MaxUsesToExplore = 0,
const LoopInfo *LI = nullptr);
@@ -73,8 +68,7 @@ namespace llvm {
// that the instruction the result value is compared against is not in a
// cycle.
Instruction *FindEarliestCapture(const Value *V, Function &F,
- bool ReturnCaptures, bool StoreCaptures,
- const DominatorTree &DT,
+ bool ReturnCaptures, const DominatorTree &DT,
unsigned MaxUsesToExplore = 0);
/// This callback is used in conjunction with PointerMayBeCaptured. In
diff --git a/llvm/lib/Analysis/AliasAnalysis.cpp b/llvm/lib/Analysis/AliasAnalysis.cpp
index 1a9136e464d25..969993c94a6e8 100644
--- a/llvm/lib/Analysis/AliasAnalysis.cpp
+++ b/llvm/lib/Analysis/AliasAnalysis.cpp
@@ -623,8 +623,7 @@ ModRefInfo AAResults::callCapturesBefore(const Instruction *I,
if (!Call || Call == Object)
return ModRefInfo::ModRef;
- if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true,
- /* StoreCaptures */ true, I, DT,
+ if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true, I, DT,
/* include Object */ true))
return ModRefInfo::ModRef;
diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
index 85b8253408ebf..0d2d6c3a8288b 100644
--- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -220,7 +220,7 @@ bool EarliestEscapeAnalysis::isNotCapturedBefore(const Value *Object,
if (Iter.second) {
Instruction *EarliestCapture = FindEarliestCapture(
Object, *const_cast<Function *>(DT.getRoot()->getParent()),
- /*ReturnCaptures=*/false, /*StoreCaptures=*/true, DT);
+ /*ReturnCaptures=*/false, DT);
if (EarliestCapture)
Inst2Obj[EarliestCapture].push_back(Object);
Iter.first->second = EarliestCapture;
diff --git a/llvm/lib/Analysis/CaptureTracking.cpp b/llvm/lib/Analysis/CaptureTracking.cpp
index d82647c7c70cf..9cb3c092768e4 100644
--- a/llvm/lib/Analysis/CaptureTracking.cpp
+++ b/llvm/lib/Analysis/CaptureTracking.cpp
@@ -198,20 +198,12 @@ struct EarliestCaptures : public CaptureTracker {
/// by the enclosing function (which is required to exist). This routine can
/// be expensive, so consider caching the results. The boolean ReturnCaptures
/// specifies whether returning the value (or part of it) from the function
-/// counts as capturing it or not. The boolean StoreCaptures specified whether
-/// storing the value (or part of it) into memory anywhere automatically
/// counts as capturing it or not.
bool llvm::PointerMayBeCaptured(const Value *V, bool ReturnCaptures,
- bool StoreCaptures, unsigned MaxUsesToExplore) {
+ unsigned MaxUsesToExplore) {
assert(!isa<GlobalValue>(V) &&
"It doesn't make sense to ask whether a global is captured.");
- // TODO: If StoreCaptures is not true, we could do Fancy analysis
- // to determine whether this store is not actually an escape point.
- // In that case, BasicAliasAnalysis should be updated as well to
- // take advantage of this.
- (void)StoreCaptures;
-
LLVM_DEBUG(dbgs() << "Captured?: " << *V << " = ");
SimpleCaptureTracker SCT(ReturnCaptures);
@@ -231,11 +223,9 @@ bool llvm::PointerMayBeCaptured(const Value *V, bool ReturnCaptures,
/// instruction are considered. This routine can be expensive, so consider
/// caching the results. The boolean ReturnCaptures specifies whether
/// returning the value (or part of it) from the function counts as capturing
-/// it or not. The boolean StoreCaptures specified whether storing the value
-/// (or part of it) into memory anywhere automatically counts as capturing it
-/// or not.
+/// it or not.
bool llvm::PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
- bool StoreCaptures, const Instruction *I,
+ const Instruction *I,
const DominatorTree *DT, bool IncludeI,
unsigned MaxUsesToExplore,
const LoopInfo *LI) {
@@ -243,11 +233,7 @@ bool llvm::PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
"It doesn't make sense to ask whether a global is captured.");
if (!DT)
- return PointerMayBeCaptured(V, ReturnCaptures, StoreCaptures,
- MaxUsesToExplore);
-
- // TODO: See comment in PointerMayBeCaptured regarding what could be done
- // with StoreCaptures.
+ return PointerMayBeCaptured(V, ReturnCaptures, MaxUsesToExplore);
CapturesBefore CB(ReturnCaptures, I, DT, IncludeI, LI);
PointerMayBeCaptured(V, &CB, MaxUsesToExplore);
@@ -259,7 +245,7 @@ bool llvm::PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
}
Instruction *llvm::FindEarliestCapture(const Value *V, Function &F,
- bool ReturnCaptures, bool StoreCaptures,
+ bool ReturnCaptures,
const DominatorTree &DT,
unsigned MaxUsesToExplore) {
assert(!isa<GlobalValue>(V) &&
@@ -469,12 +455,7 @@ bool llvm::isNonEscapingLocalObject(
// If this is an identified function-local object, check to see if it escapes.
if (isIdentifiedFunctionLocal(V)) {
- // Set StoreCaptures to True so that we can assume in our callers that the
- // pointer is not the result of a load instruction. Currently
- // PointerMayBeCaptured doesn't have any special analysis for the
- // StoreCaptures=false case; if it did, our callers could be refined to be
- // more precise.
- auto Ret = !PointerMayBeCaptured(V, false, /*StoreCaptures=*/true);
+ auto Ret = !PointerMayBeCaptured(V, /*ReturnCaptures=*/false);
if (IsCapturedCache)
CacheIt->second = Ret;
return Ret;
diff --git a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp
index a63e38a7d98ad..5c717a726b261 100644
--- a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp
+++ b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp
@@ -1430,7 +1430,7 @@ static bool isFunctionMallocLike(Function *F, const SCCNodeSet &SCCNodes) {
return false; // Did not come from an allocation.
}
- if (PointerMayBeCaptured(RetVal, false, /*StoreCaptures=*/false))
+ if (PointerMayBeCaptured(RetVal, /*ReturnCaptures=*/false))
return false;
}
diff --git a/llvm/lib/Transforms/Instrumentation/SanitizerBinaryMetadata.cpp b/llvm/lib/Transforms/Instrumentation/SanitizerBinaryMetadata.cpp
index 1759b95ddbc30..9ebc235f58142 100644
--- a/llvm/lib/Transforms/Instrumentation/SanitizerBinaryMetadata.cpp
+++ b/llvm/lib/Transforms/Instrumentation/SanitizerBinaryMetadata.cpp
@@ -394,7 +394,7 @@ bool maybeSharedMutable(const Value *Addr) {
return true;
if (isa<AllocaInst>(getUnderlyingObject(Addr)) &&
- !PointerMayBeCaptured(Addr, true, true))
+ !PointerMayBeCaptured(Addr, /*ReturnCaptures=*/true))
return false; // Object is on stack but does not escape.
Addr = Addr->stripInBoundsOffsets();
diff --git a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
index 7deaac5e59a28..57e7667150b99 100644
--- a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
+++ b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
@@ -449,7 +449,7 @@ void ThreadSanitizer::chooseInstructionsToInstrument(
}
if (isa<AllocaInst>(getUnderlyingObject(Addr)) &&
- !PointerMayBeCaptured(Addr, true, true)) {
+ !PointerMayBeCaptured(Addr, /*ReturnCaptures=*/true)) {
// The variable is addressable but not captured, so it cannot be
// referenced from a
diff erent thread and participate in a data race
// (see llvm/Analysis/CaptureTracking.h for details).
diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
index f3b53e05c519e..06ac209f9fe5c 100644
--- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
@@ -1200,7 +1200,7 @@ struct DSEState {
if (!isInvisibleToCallerOnUnwind(V)) {
I.first->second = false;
} else if (isNoAliasCall(V)) {
- I.first->second = !PointerMayBeCaptured(V, true, false);
+ I.first->second = !PointerMayBeCaptured(V, /*ReturnCaptures=*/true);
}
}
return I.first->second;
@@ -1219,7 +1219,7 @@ struct DSEState {
// with the killing MemoryDef. But we refrain from doing so for now to
// limit compile-time and this does not cause any changes to the number
// of stores removed on a large test set in practice.
- I.first->second = PointerMayBeCaptured(V, false, true);
+ I.first->second = PointerMayBeCaptured(V, /*ReturnCaptures=*/false);
return !I.first->second;
}
diff --git a/llvm/lib/Transforms/Scalar/LICM.cpp b/llvm/lib/Transforms/Scalar/LICM.cpp
index 1a65154ae5936..7f2554409bc6a 100644
--- a/llvm/lib/Transforms/Scalar/LICM.cpp
+++ b/llvm/lib/Transforms/Scalar/LICM.cpp
@@ -1935,7 +1935,6 @@ bool isNotCapturedBeforeOrInLoop(const Value *V, const Loop *L,
// the loop.
// TODO: ReturnCaptures=true shouldn't be necessary here.
return !PointerMayBeCapturedBefore(V, /* ReturnCaptures */ true,
- /* StoreCaptures */ true,
L->getHeader()->getTerminator(), DT);
}
diff --git a/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp b/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
index 87b27beb01a0a..43496d1c80df5 100644
--- a/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
+++ b/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
@@ -994,8 +994,7 @@ bool MemCpyOptPass::performCallSlotOptzn(Instruction *cpyLoad,
// or src pointer.
Value *DestObj = getUnderlyingObject(cpyDest);
if (!isIdentifiedFunctionLocal(DestObj) ||
- PointerMayBeCapturedBefore(DestObj, /* ReturnCaptures */ true,
- /* StoreCaptures */ true, C, DT,
+ PointerMayBeCapturedBefore(DestObj, /* ReturnCaptures */ true, C, DT,
/* IncludeI */ true))
return false;
diff --git a/llvm/lib/Transforms/Utils/InlineFunction.cpp b/llvm/lib/Transforms/Utils/InlineFunction.cpp
index b92d8b16daad2..c78cd0b92ab94 100644
--- a/llvm/lib/Transforms/Utils/InlineFunction.cpp
+++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp
@@ -1313,8 +1313,7 @@ static void AddAliasScopeMetadata(CallBase &CB, ValueToValueMapTy &VMap,
// nocapture only guarantees that no copies outlive the function, not
// that the value cannot be locally captured.
if (!RequiresNoCaptureBefore ||
- !PointerMayBeCapturedBefore(A, /* ReturnCaptures */ false,
- /* StoreCaptures */ false, I, &DT))
+ !PointerMayBeCapturedBefore(A, /* ReturnCaptures */ false, I, &DT))
NoAliases.push_back(NewScopes[A]);
}
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
index 21a267d41bd8e..c71605c500686 100644
--- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -3036,8 +3036,7 @@ static Value *isSafeToSpeculateStore(Instruction *I, BasicBlock *BrBB,
Value *Obj = getUnderlyingObject(StorePtr);
bool ExplicitlyDereferenceableOnly;
if (isWritableObject(Obj, ExplicitlyDereferenceableOnly) &&
- !PointerMayBeCaptured(Obj, /*ReturnCaptures=*/false,
- /*StoreCaptures=*/true) &&
+ !PointerMayBeCaptured(Obj, /*ReturnCaptures=*/false) &&
(!ExplicitlyDereferenceableOnly ||
isDereferenceablePointer(StorePtr, StoreTy,
LI->getDataLayout()))) {
diff --git a/llvm/unittests/Analysis/CaptureTrackingTest.cpp b/llvm/unittests/Analysis/CaptureTrackingTest.cpp
index 73dd82fb921f7..b6d075c28cc9d 100644
--- a/llvm/unittests/Analysis/CaptureTrackingTest.cpp
+++ b/llvm/unittests/Analysis/CaptureTrackingTest.cpp
@@ -56,17 +56,17 @@ TEST(CaptureTracking, MaxUsesToExplore) {
ASSERT_NE(F, nullptr);
Value *Arg = &*F->arg_begin();
ASSERT_NE(Arg, nullptr);
- ASSERT_FALSE(PointerMayBeCaptured(Arg, true, true, FalseMaxUsesLimit));
- ASSERT_TRUE(PointerMayBeCaptured(Arg, true, true, TrueMaxUsesLimit));
+ ASSERT_FALSE(PointerMayBeCaptured(Arg, true, FalseMaxUsesLimit));
+ ASSERT_TRUE(PointerMayBeCaptured(Arg, true, TrueMaxUsesLimit));
BasicBlock *EntryBB = &F->getEntryBlock();
DominatorTree DT(*F);
Instruction *Ret = EntryBB->getTerminator();
ASSERT_TRUE(isa<ReturnInst>(Ret));
- ASSERT_FALSE(PointerMayBeCapturedBefore(Arg, true, true, Ret, &DT, false,
+ ASSERT_FALSE(PointerMayBeCapturedBefore(Arg, true, Ret, &DT, false,
FalseMaxUsesLimit));
- ASSERT_TRUE(PointerMayBeCapturedBefore(Arg, true, true, Ret, &DT, false,
+ ASSERT_TRUE(PointerMayBeCapturedBefore(Arg, true, Ret, &DT, false,
TrueMaxUsesLimit));
};
More information about the llvm-commits
mailing list