Include calling address in tracked activities.

base/debug/activity_tracker.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/activity_tracker.h"
 
 #include "base/debug/stack_trace.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 133 matching lines @@
 
   // Add this reference to our "free" cache if there is space. If not, the type
   // has still been changed to indicate that it is free so this (or another)
   // thread can find it, albeit more slowly, using the iteration method above.
   if (cache_used_ < cache_size_)
     cache_values_[cache_used_++] = ref;
 }
 
 // static
 void Activity::FillFrom(Activity* activity,
+                        const void* program_counter,
                         const void* origin,
                         Type type,
                         const ActivityData& data) {
   activity->time_internal = base::TimeTicks::Now().ToInternalValue();
+  activity->calling_address = reinterpret_cast<uintptr_t>(program_counter);
   activity->origin_address = reinterpret_cast<uintptr_t>(origin);
   activity->activity_type = type;
   activity->data = data;
 
 #if defined(SYZYASAN)
   // Create a stacktrace from the current location and get the addresses.
   StackTrace stack_trace;
   size_t stack_depth;
   const void* const* stack_addrs = stack_trace.Addresses(&stack_depth);
   // Copy the stack addresses, ignoring the first one (here).
@@ skipping 134 matching lines @@
     DCHECK(IsValid());
   } else {
     // This is a file with existing data. Perform basic consistency checks.
     valid_ = true;
     valid_ = IsValid();
   }
 }
 
 ThreadActivityTracker::~ThreadActivityTracker() {}
 
-void ThreadActivityTracker::PushActivity(const void* origin,
+void ThreadActivityTracker::PushActivity(const void* program_counter,
+                                         const void* origin,
                                          Activity::Type type,
                                          const ActivityData& data) {
   // A thread-checker creates a lock to check the thread-id which means
   // re-entry into this code if lock acquisitions are being tracked.
   DCHECK(type == Activity::ACT_LOCK_ACQUIRE ||
          thread_checker_.CalledOnValidThread());
 
   // Get the current depth of the stack. No access to other memory guarded
   // by this variable is done here so a "relaxed" load is acceptable.
   uint32_t depth = header_->current_depth.load(std::memory_order_relaxed);
 
   // Handle the case where the stack depth has exceeded the storage capacity.
   // Extra entries will be lost leaving only the base of the stack.
   if (depth >= stack_slots_) {
     // Since no other threads modify the data, no compare/exchange is needed.
     // Since no other memory is being modified, a "relaxed" store is acceptable.
     header_->current_depth.store(depth + 1, std::memory_order_relaxed);
     return;
   }
 
   // Get a pointer to the next activity and load it. No atomicity is required
   // here because the memory is known only to this thread. It will be made
   // known to other threads once the depth is incremented.
-  Activity::FillFrom(&stack_[depth], origin, type, data);
+  Activity::FillFrom(&stack_[depth], program_counter, origin, type, data);
 
   // Save the incremented depth. Because this guards |activity| memory filled
   // above that may be read by another thread once the recorded depth changes,
   // a "release" store is required.
   header_->current_depth.store(depth + 1, std::memory_order_release);
 }
 
 void ThreadActivityTracker::ChangeActivity(Activity::Type type,
                                            const ActivityData& data) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 324 matching lines @@
   // Release this memory for re-use at a later time.
   base::AutoLock autolock(thread_tracker_allocator_lock_);
   thread_tracker_allocator_.ReleaseObjectReference(mem_reference);
 }
 
 // static
 void GlobalActivityTracker::OnTLSDestroy(void* value) {
   delete reinterpret_cast<ManagedActivityTracker*>(value);
 }
 
-ScopedActivity::ScopedActivity(const tracked_objects::Location& location,
+ScopedActivity::ScopedActivity(const void* program_counter,
                                uint8_t action,
                                uint32_t id,
                                int32_t info)
     : GlobalActivityTracker::ScopedThreadActivity(
-          location.program_counter(),
+          program_counter,
+          nullptr,
           static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
           ActivityData::ForGeneric(id, info),
           /*lock_allowed=*/true),
       id_(id) {
   // The action must not affect the category bits of the activity type.
   DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
 }
 
 void ScopedActivity::ChangeAction(uint8_t action) {
   DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
   ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
                     kNullActivityData);
 }
 
 void ScopedActivity::ChangeInfo(int32_t info) {
   ChangeTypeAndData(Activity::ACT_NULL, ActivityData::ForGeneric(id_, info));
 }
 
 void ScopedActivity::ChangeActionAndInfo(uint8_t action, int32_t info) {
   DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
   ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
                     ActivityData::ForGeneric(id_, info));
 }
 
-ScopedTaskRunActivity::ScopedTaskRunActivity(const base::PendingTask& task)
+ScopedTaskRunActivity::ScopedTaskRunActivity(
+    const void* program_counter,
+    const base::PendingTask& task)
     : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
           task.posted_from.program_counter(),
           Activity::ACT_TASK_RUN,
           ActivityData::ForTask(task.sequence_num),
           /*lock_allowed=*/true) {}
 
 ScopedLockAcquireActivity::ScopedLockAcquireActivity(
+    const void* program_counter,
     const base::internal::LockImpl* lock)
     : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
           nullptr,
           Activity::ACT_LOCK_ACQUIRE,
           ActivityData::ForLock(lock),
           /*lock_allowed=*/false) {}
 
 ScopedEventWaitActivity::ScopedEventWaitActivity(
+    const void* program_counter,
     const base::WaitableEvent* event)
     : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
           nullptr,
           Activity::ACT_EVENT_WAIT,
           ActivityData::ForEvent(event),
           /*lock_allowed=*/true) {}
 
 ScopedThreadJoinActivity::ScopedThreadJoinActivity(
+    const void* program_counter,
     const base::PlatformThreadHandle* thread)
     : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
           nullptr,
           Activity::ACT_THREAD_JOIN,
           ActivityData::ForThread(*thread),
           /*lock_allowed=*/true) {}
 
 #if !defined(OS_NACL) && !defined(OS_IOS)
 ScopedProcessWaitActivity::ScopedProcessWaitActivity(
+    const void* program_counter,
     const base::Process* process)
     : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base