Implement ThreadDelegateAndroid and supply to StackCopierSignal

Implements the ThreadDelegate abstraction for Android, providing the
stack base address and registers that may require rewriting to update
them from pointing to the original stack to the copied stack.

Removes code from the TracingSamplerProfiler that was attempting
to use the StackSamplingProfiler with the built-in Android
StackSampler. This had no effect previously and crashes with the
current skeleton implementation. Tracing will be able to use the
built-in sampler when it's in a more mature state.

Bug: 988579
Change-Id: I4c44bbec33f2e1457c03de37d8c852a85eb9d65b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1764288Reviewed-by: Charlie Andrews <charliea@chromium.org>
Reviewed-by: ssid <ssid@chromium.org>
Commit-Queue: Mike Wittman <wittman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#694911}

base/profiler/register_context.h

@@ -17,6 +17,8 @@
 #include <windows.h>
 #elif defined(OS_MACOSX)
 #include <mach/machine/thread_status.h>
+#elif defined(OS_ANDROID) && !defined(ARCH_CPU_64_BITS)
+#include <sys/ucontext.h>
 #endif
 
 namespace base {
@@ -83,6 +85,23 @@ inline uintptr_t& RegisterContextInstructionPointer(
   return AsUintPtr(&context->__rip);
 }
 
+#elif defined(OS_ANDROID) && defined(ARCH_CPU_ARM_FAMILY) && \
+    defined(ARCH_CPU_32_BITS)  // #if defined(OS_WIN)
+
+using RegisterContext = mcontext_t;
+
+inline uintptr_t& RegisterContextStackPointer(mcontext_t* context) {
+  return AsUintPtr(&context->arm_sp);
+}
+
+inline uintptr_t& RegisterContextFramePointer(mcontext_t* context) {
+  return AsUintPtr(&context->arm_fp);
+}
+
+inline uintptr_t& RegisterContextInstructionPointer(mcontext_t* context) {
+  return AsUintPtr(&context->arm_ip);
+}
+
 #else  // #if defined(OS_WIN)
 
 // Placeholders for other platforms.

base/profiler/stack_copier_signal.cc

@@ -11,7 +11,9 @@
 
 namespace base {
 
-StackCopierSignal::StackCopierSignal() = default;
+StackCopierSignal::StackCopierSignal(
+    std::unique_ptr<ThreadDelegate> thread_delegate)
+    : thread_delegate_(std::move(thread_delegate)) {}
 
 StackCopierSignal::~StackCopierSignal() = default;
 

base/profiler/stack_copier_signal.h

@@ -5,16 +5,20 @@
 #ifndef BASE_PROFILER_STACK_COPIER_SIGNAL_H_
 #define BASE_PROFILER_STACK_COPIER_SIGNAL_H_
 
+#include <memory>
+
 #include "base/base_export.h"
 #include "base/profiler/stack_copier.h"
 
 namespace base {
 
+class ThreadDelegate;
+
 // Supports stack copying on platforms where a signal must be delivered to the
 // profiled thread and the stack is copied from the signal handler.
 class BASE_EXPORT StackCopierSignal : public StackCopier {
  public:
-  StackCopierSignal();
+  StackCopierSignal(std::unique_ptr<ThreadDelegate> thread_delegate);
   ~StackCopierSignal() override;
 
   // StackCopier:
@@ -22,6 +26,9 @@ class BASE_EXPORT StackCopierSignal : public StackCopier {
                  uintptr_t* stack_top,
                  ProfileBuilder* profile_builder,
                  RegisterContext* thread_context) override;
+
+ private:
+  std::unique_ptr<ThreadDelegate> thread_delegate_;
 };
 
 }  // namespace base

base/profiler/stack_sampler_android.cc

@@ -9,6 +9,7 @@
 #include "base/profiler/native_unwinder_android.h"
 #include "base/profiler/stack_copier_signal.h"
 #include "base/profiler/stack_sampler_impl.h"
+#include "base/profiler/thread_delegate_android.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
@@ -18,7 +19,8 @@ std::unique_ptr<StackSampler> StackSampler::Create(
     ModuleCache* module_cache,
     StackSamplerTestDelegate* test_delegate) {
   return std::make_unique<StackSamplerImpl>(
-      std::make_unique<StackCopierSignal>(),
+      std::make_unique<StackCopierSignal>(
+          std::make_unique<ThreadDelegateAndroid>(thread_id)),
       std::make_unique<NativeUnwinderAndroid>(), module_cache, test_delegate);
 }
 

base/profiler/thread_delegate_android.cc

@@ -2,8 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <pthread.h>
+
 #include "base/profiler/thread_delegate_android.h"
 
+#include "build/build_config.h"
+
 // IMPORTANT NOTE: Some functions within this implementation are invoked while
 // the target thread is suspended so it must not do any allocation from the
 // heap, including indirectly via use of DCHECK/CHECK or other logging
@@ -13,15 +17,50 @@
 
 namespace base {
 
+namespace {
+
+uintptr_t GetThreadStackBaseAddress(PlatformThreadId thread_id) {
+  pthread_attr_t attr;
+  pthread_getattr_np(thread_id, &attr);
+  void* base_address;
+  size_t size;
+  pthread_attr_getstack(&attr, &base_address, &size);
+  return reinterpret_cast<uintptr_t>(base_address);
+}
+
+}  // namespace
+
+ThreadDelegateAndroid::ThreadDelegateAndroid(PlatformThreadId thread_id)
+    : thread_stack_base_address_(GetThreadStackBaseAddress(thread_id)) {}
+
 uintptr_t ThreadDelegateAndroid::GetStackBaseAddress() const {
-  // It's okay for the stub to return zero here: GetStackBaseAddress() if
-  // ScopedSuspendThread fails, which it always will in the stub.
-  return 0;
+  return thread_stack_base_address_;
 }
 
 std::vector<uintptr_t*> ThreadDelegateAndroid::GetRegistersToRewrite(
     RegisterContext* thread_context) {
+#if defined(ARCH_CPU_ARM_FAMILY) && defined(ARCH_CPU_32_BITS)
+  return {
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r0),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r1),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r2),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r3),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r4),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r5),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r6),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r7),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r8),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r9),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_r10),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_fp),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_ip),
+      reinterpret_cast<uintptr_t*>(&thread_context->arm_sp),
+      // arm_lr and arm_pc do not require rewriting because they contain
+      // addresses of executable code, not addresses in the stack.
+  };
+#else  // #if defined(ARCH_CPU_ARM_FAMILY) && defined(ARCH_CPU_32_BITS)
   return {};
+#endif
 }
 
 }  // namespace base

base/profiler/thread_delegate_android.h

@@ -7,6 +7,7 @@
 
 #include "base/base_export.h"
 #include "base/profiler/thread_delegate.h"
+#include "base/threading/platform_thread.h"
 
 namespace base {
 
@@ -16,7 +17,7 @@ namespace base {
 // TODO(https://crbug.com/988579): Implement this class.
 class BASE_EXPORT ThreadDelegateAndroid : public ThreadDelegate {
  public:
-  ThreadDelegateAndroid() = default;
+  ThreadDelegateAndroid(PlatformThreadId thread_id);
 
   ThreadDelegateAndroid(const ThreadDelegateAndroid&) = delete;
   ThreadDelegateAndroid& operator=(const ThreadDelegateAndroid&) = delete;
@@ -25,6 +26,9 @@ class BASE_EXPORT ThreadDelegateAndroid : public ThreadDelegate {
   uintptr_t GetStackBaseAddress() const override;
   std::vector<uintptr_t*> GetRegistersToRewrite(
       RegisterContext* thread_context) override;
+
+ private:
+  const uintptr_t thread_stack_base_address_;
 };
 
 }  // namespace base

services/tracing/public/cpp/stack_sampling/tracing_sampler_profiler.cc

@@ -547,19 +547,19 @@ void TracingSamplerProfiler::StartTracing(
       sampled_thread_id_, std::move(trace_writer), should_enable_filtering);
   profile_builder_ = profile_builder.get();
   // Create and start the stack sampling profiler.
-#if defined(OS_ANDROID) && BUILDFLAG(CAN_UNWIND_WITH_CFI_TABLE) && \
-    defined(OFFICIAL_BUILD)
+#if defined(OS_ANDROID)
+#if BUILDFLAG(CAN_UNWIND_WITH_CFI_TABLE) && defined(OFFICIAL_BUILD)
   auto* module_cache = profile_builder->GetModuleCache();
   profiler_ = std::make_unique<base::StackSamplingProfiler>(
       sampled_thread_id_, params, std::move(profile_builder),
       std::make_unique<StackSamplerAndroid>(sampled_thread_id_, module_cache));
-
-#else
+  profiler_->Start();
+#endif  // BUILDFLAG(CAN_UNWIND_WITH_CFI_TABLE) && defined(OFFICIAL_BUILD)
+#else   // defined(OS_ANDROID)
   profiler_ = std::make_unique<base::StackSamplingProfiler>(
       sampled_thread_id_, params, std::move(profile_builder));
-#endif
-
   profiler_->Start();
+#endif  // defined(OS_ANDROID)
 }
 
 void TracingSamplerProfiler::StopTracing() {