[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.

Author: nikic

Diff for: llvm/include/llvm/Analysis/CaptureTracking.h

@@ -35,31 +35,26 @@ 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
   /// DominatorTree is provided, only captures which happen before the given
   /// 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 for: 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 for: 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 for: 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,23 +223,17 @@ 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) {
   assert(!isa<GlobalValue>(V) &&
          "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 for: 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 for: 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 for: 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 different thread and participate in a data race
       // (see llvm/Analysis/CaptureTracking.h for details).

Diff for: 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 for: 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 for: 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 for: 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 for: 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 for: 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));
   };