[CaptureTracking][NFC] Clarify usage expectations in PointerMayBeCaptured comments

llvm/include/llvm/Analysis/CaptureTracking.h

@@ -41,13 +41,17 @@ namespace llvm {
   /// 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.
+  /// This assumes the pointer is to a function-local object. The caller is
+  /// responsible for ensuring this.
   bool PointerMayBeCaptured(const Value *V, bool ReturnCaptures,
                             unsigned MaxUsesToExplore = 0);
 
   /// Return which components of the pointer may be captured. Only consider
   /// components that are part of \p Mask. Once \p StopFn on the accumulated
   /// components returns true, the traversal is aborted early. By default, this
   /// happens when *any* of the components in \p Mask are captured.
+  /// This assumes the pointer is to a function-local object. The caller is
+  /// responsible for ensuring this.
   CaptureComponents PointerMayBeCaptured(
       const Value *V, bool ReturnCaptures, CaptureComponents Mask,
       function_ref<bool(CaptureComponents)> StopFn = capturesAnything,
@@ -64,6 +68,8 @@ namespace llvm {
   /// 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.
+  /// This assumes the pointer is to a function-local object. The caller is
+  /// responsible for ensuring this.
   bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures,
                                   const Instruction *I, const DominatorTree *DT,
                                   bool IncludeI = false,
@@ -184,6 +190,8 @@ namespace llvm {
   /// 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.
+  /// This assumes the pointer is to a function-local object. The caller is
+  /// responsible for ensuring this.
   void PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker,
                             unsigned MaxUsesToExplore = 0);
 

llvm/lib/Analysis/CaptureTracking.cpp

@@ -424,10 +424,6 @@ void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker,
   if (MaxUsesToExplore == 0)
     MaxUsesToExplore = DefaultMaxUsesToExplore;
 
-  // When analyzing a derived pointer, we need to analyze its underlying
-  // object to determine whether it is captured.
-  // E.g., `ptr + 1` is captured if `ptr` is captured.
-  V = getUnderlyingObjectAggressive(V);
   SmallVector<const Use *, 20> Worklist;
   Worklist.reserve(getDefaultMaxUsesToExploreForCaptureTracking());
   SmallSet<const Use *, 20> Visited;

llvm/unittests/Analysis/CaptureTrackingTest.cpp

@@ -132,31 +132,3 @@ TEST(CaptureTracking, MultipleUsesInSameInstruction) {
   EXPECT_EQ(ICmp, CT.Captures[6]->getUser());
   EXPECT_EQ(1u, CT.Captures[6]->getOperandNo());
 }
-
-TEST(CaptureTracking, DerivedPointerIfBasePointerCaptured) {
-  StringRef Assembly = R"(
-    declare void @bar(ptr)
-
-    define void @test() {
-      %stack_obj = alloca [2 x i32]
-      %derived = getelementptr inbounds [2 x i32], ptr %stack_obj, i64 0, i64 1
-      store i32 1, ptr %derived
-      call void @bar(ptr %stack_obj)
-      ret void
-    }
-  )";
-
-  LLVMContext Context;
-  SMDiagnostic Error;
-  auto M = parseAssemblyString(Assembly, Error, Context);
-  ASSERT_TRUE(M) << "Bad assembly?";
-
-  Function *F = M->getFunction("test");
-  BasicBlock *BB = &F->getEntryBlock();
-  Instruction *StackObj = &*BB->begin();
-  Instruction *DerivedPtr = StackObj->getNextNode();
-
-  // The base object and its derived pointer are both captured.
-  EXPECT_TRUE(PointerMayBeCaptured(StackObj, true));
-  EXPECT_TRUE(PointerMayBeCaptured(DerivedPtr, true));
-}