Revert of NativeStackSampler implementation for Mac.

base/profiler/native_stack_sampler_mac.cc

Index: base/profiler/native_stack_sampler_mac.cc
diff --git a/base/profiler/native_stack_sampler_mac.cc b/base/profiler/native_stack_sampler_mac.cc
deleted file mode 100644
index 6eb655c21da41df1c6d48db31b9b1b718348e915..0000000000000000000000000000000000000000
--- a/base/profiler/native_stack_sampler_mac.cc
+++ /dev/null
@@ -1,471 +0,0 @@
-// Copyright 2017 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/profiler/native_stack_sampler.h"
-
-#include <dlfcn.h>
-#include <libkern/OSByteOrder.h>
-#include <libunwind.h>
-#include <mach-o/swap.h>
-#include <mach/kern_return.h>
-#include <mach/mach.h>
-#include <mach/thread_act.h>
-#include <pthread.h>
-#include <sys/resource.h>
-#include <sys/syslimits.h>
-
-#include <algorithm>
-#include <map>
-#include <memory>
-
-#include "base/logging.h"
-#include "base/mac/mach_logging.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/string_number_conversions.h"
-
-namespace base {
-
-namespace {
-
-// Miscellaneous --------------------------------------------------------------
-
-size_t StackCopyBufferSize() {
-  static size_t stack_size = 0;
-  if (stack_size)
-    return stack_size;
-
-  // In platform_thread_mac's GetDefaultThreadStackSize(), RLIMIT_STACK is used
-  // for all stacks, not just the main thread's, so it is good for use here.
-  struct rlimit stack_rlimit;
-  if (getrlimit(RLIMIT_STACK, &stack_rlimit) == 0 &&
-      stack_rlimit.rlim_cur != RLIM_INFINITY) {
-    stack_size = stack_rlimit.rlim_cur;
-    return stack_size;
-  }
-
-  // If getrlimit somehow fails, return the default macOS main thread stack size
-  // of 8 MB (DFLSSIZ in <i386/vmparam.h>) with extra wiggle room.
-  return 12 * 1024 * 1024;
-}
-
-// Stack walking --------------------------------------------------------------
-
-// Fills |state| with |target_thread|'s context.
-//
-// Note that this is called while a thread is suspended. Make very very sure
-// that no shared resources (e.g. memory allocators) are used for the duration
-// of this function.
-bool GetThreadState(thread_act_t target_thread, x86_thread_state64_t* state) {
-  mach_msg_type_number_t count =
-      static_cast<mach_msg_type_number_t>(x86_THREAD_STATE64_COUNT);
-  return thread_get_state(target_thread, x86_THREAD_STATE64,
-                          reinterpret_cast<thread_state_t>(state),
-                          &count) == KERN_SUCCESS;
-}
-
-// If the value at |pointer| points to the original stack, rewrites it to point
-// to the corresponding location in the copied stack.
-//
-// Note that this is called while a thread is suspended. Make very very sure
-// that no shared resources (e.g. memory allocators) are used for the duration
-// of this function.
-uintptr_t RewritePointerIfInOriginalStack(
-    const uintptr_t* original_stack_bottom,
-    const uintptr_t* original_stack_top,
-    uintptr_t* stack_copy_bottom,
-    uintptr_t pointer) {
-  uintptr_t original_stack_bottom_int =
-      reinterpret_cast<uintptr_t>(original_stack_bottom);
-  uintptr_t original_stack_top_int =
-      reinterpret_cast<uintptr_t>(original_stack_top);
-  uintptr_t stack_copy_bottom_int =
-      reinterpret_cast<uintptr_t>(stack_copy_bottom);
-
-  if ((pointer < original_stack_bottom_int) ||
-      (pointer >= original_stack_top_int)) {
-    return pointer;
-  }
-
-  return stack_copy_bottom_int + (pointer - original_stack_bottom_int);
-}
-
-// Copies the stack to a buffer while rewriting possible pointers to locations
-// within the stack to point to the corresponding locations in the copy. This is
-// necessary to handle stack frames with dynamic stack allocation, where a
-// pointer to the beginning of the dynamic allocation area is stored on the
-// stack and/or in a non-volatile register.
-//
-// Eager rewriting of anything that looks like a pointer to the stack, as done
-// in this function, does not adversely affect the stack unwinding. The only
-// other values on the stack the unwinding depends on are return addresses,
-// which should not point within the stack memory. The rewriting is guaranteed
-// to catch all pointers because the stacks are guaranteed by the ABI to be
-// sizeof(void*) aligned.
-//
-// Note that this is called while a thread is suspended. Make very very sure
-// that no shared resources (e.g. memory allocators) are used for the duration
-// of this function.
-void CopyStackAndRewritePointers(uintptr_t* stack_copy_bottom,
-                                 const uintptr_t* original_stack_bottom,
-                                 const uintptr_t* original_stack_top,
-                                 x86_thread_state64_t* thread_state)
-    NO_SANITIZE("address") {
-  size_t count = original_stack_top - original_stack_bottom;
-  for (size_t pos = 0; pos < count; ++pos) {
-    stack_copy_bottom[pos] = RewritePointerIfInOriginalStack(
-        original_stack_bottom, original_stack_top, stack_copy_bottom,
-        original_stack_bottom[pos]);
-  }
-
-  uint64_t* rewrite_registers[] = {&thread_state->__rbx, &thread_state->__rbp,
-                                   &thread_state->__rsp, &thread_state->__r12,
-                                   &thread_state->__r13, &thread_state->__r14,
-                                   &thread_state->__r15};
-  for (auto* reg : rewrite_registers) {
-    *reg = RewritePointerIfInOriginalStack(
-        original_stack_bottom, original_stack_top, stack_copy_bottom, *reg);
-  }
-}
-
-// Walks the stack represented by |unwind_context|, calling back to the provided
-// lambda for each frame. Returns false if an error occurred, otherwise returns
-// true.
-template <typename StackFrameCallback>
-bool WalkStackFromContext(unw_context_t* unwind_context,
-                          size_t* frame_count,
-                          const StackFrameCallback& callback) {
-  unw_cursor_t unwind_cursor;
-  unw_init_local(&unwind_cursor, unwind_context);
-
-  int step_result;
-  unw_word_t ip;
-  do {
-    ++(*frame_count);
-    unw_get_reg(&unwind_cursor, UNW_REG_IP, &ip);
-
-    callback(static_cast<uintptr_t>(ip));
-
-    step_result = unw_step(&unwind_cursor);
-  } while (step_result > 0);
-
-  if (step_result != 0)
-    return false;
-
-  return true;
-}
-
-bool IsIPInValidImage(unw_context_t* unwind_context) {
-  unw_cursor_t unwind_cursor;
-  unw_init_local(&unwind_cursor, unwind_context);
-  unw_proc_info_t proc_info;
-  unw_get_proc_info(&unwind_cursor, &proc_info);
-  return proc_info.extra != 0;
-}
-
-// Walks the stack represented by |thread_state|, calling back to the provided
-// lambda for each frame.
-template <typename StackFrameCallback>
-void WalkStack(const x86_thread_state64_t& thread_state,
-               uintptr_t stack_top,
-               const StackFrameCallback& callback) {
-  size_t frame_count = 0;
-  // This uses libunwind to walk the stack. libunwind is designed to be used for
-  // a thread to walk its own stack. This creates two problems.
-
-  // Problem 1: There is no official way to create a unw_context other than to
-  // create it from the current state of the current thread's stack. To get
-  // around this, forge a context. A unw_context is just a copy of the 16 main
-  // registers followed by the instruction pointer, nothing more.
-  // Coincidentally, the first 17 items of the x86_thread_state64_t type are
-  // exactly those registers in exactly the same order, so just bulk copy them
-  // over.
-  unw_context_t unwind_context;
-  memcpy(&unwind_context, &thread_state, sizeof(uintptr_t) * 17);
-  bool result = WalkStackFromContext(&unwind_context, &frame_count, callback);
-
-  if (!result)
-    return;
-
-  if (frame_count == 1) {
-    // Problem 2: Because libunwind is designed to be triggered by user code on
-    // their own thread, if it hits a library that has no unwind info for the
-    // function that is being executed, it just stops. This isn't a problem in
-    // the normal case, but in this case, it's quite possible that the stack
-    // being walked is stopped in a function that bridges to the kernel and thus
-    // is missing the unwind info.
-    //
-    // If so, cheat by scanning the stack and trying again. Only do this if the
-    // first time using libunwind fails after one frame.
-    bool ip_in_valid_image = false;
-    auto& rsp = unwind_context.data[7];
-    auto& rip = unwind_context.data[16];
-    const uintptr_t kMaxScanDepthWords = 16;
-    uintptr_t scan_limit = std::min<uintptr_t>(
-        stack_top, rsp + kMaxScanDepthWords * sizeof(uintptr_t));
-    do {
-      rip = *reinterpret_cast<uintptr_t*>(rsp);  // rip = *rsp
-      rsp += sizeof(uintptr_t);                  // rsp++
-      if (rsp % sizeof(uintptr_t)) {
-        // The "stack pointer" isn't aligned. Just give up.
-        return;
-      }
-
-      ip_in_valid_image = IsIPInValidImage(&unwind_context);
-    } while (!ip_in_valid_image && rsp < scan_limit);
-
-    if (ip_in_valid_image)
-      WalkStackFromContext(&unwind_context, &frame_count, callback);
-  }
-}
-
-// Module identifiers ---------------------------------------------------------
-
-// Returns the hex encoding of a 16-byte ID for the binary loaded at
-// |module_addr|. Returns an empty string if the UUID cannot be found at
-// |module_addr|.
-std::string GetUniqueId(const void* module_addr) {
-  const mach_header_64* mach_header =
-      reinterpret_cast<const mach_header_64*>(module_addr);
-  DCHECK_EQ(MH_MAGIC_64, mach_header->magic);
-
-  size_t offset = sizeof(mach_header_64);
-  size_t offset_limit = sizeof(mach_header_64) + mach_header->sizeofcmds;
-  for (uint32_t i = 0; (i < mach_header->ncmds) &&
-                       (offset + sizeof(load_command) < offset_limit);
-       ++i) {
-    const load_command* current_cmd = reinterpret_cast<const load_command*>(
-        reinterpret_cast<const uint8_t*>(mach_header) + offset);
-
-    if (offset + current_cmd->cmdsize > offset_limit) {
-      // This command runs off the end of the command list. This is malformed.
-      return std::string();
-    }
-
-    if (current_cmd->cmd == LC_UUID) {
-      if (current_cmd->cmdsize < sizeof(uuid_command)) {
-        // This "UUID command" is too small. This is malformed.
-        return std::string();
-      }
-
-      const uuid_command* uuid_cmd =
-          reinterpret_cast<const uuid_command*>(current_cmd);
-      static_assert(sizeof(uuid_cmd->uuid) == sizeof(uuid_t),
-                    "UUID field of UUID command should be 16 bytes.");
-      return HexEncode(&uuid_cmd->uuid, sizeof(uuid_cmd->uuid));
-    }
-    offset += current_cmd->cmdsize;
-  }
-  return std::string();
-}
-
-// Gets the index for the Module containing |instruction_pointer| in
-// |modules|, adding it if it's not already present. Returns
-// StackSamplingProfiler::Frame::kUnknownModuleIndex if no Module can be
-// determined for |module|.
-size_t GetModuleIndex(const uintptr_t instruction_pointer,
-                      std::vector<StackSamplingProfiler::Module>* modules,
-                      std::map<const void*, size_t>* profile_module_index) {
-  Dl_info inf;
-  if (!dladdr(reinterpret_cast<const void*>(instruction_pointer), &inf))
-    return StackSamplingProfiler::Frame::kUnknownModuleIndex;
-
-  auto module_index = profile_module_index->find(inf.dli_fbase);
-  if (module_index == profile_module_index->end()) {
-    StackSamplingProfiler::Module module(
-        reinterpret_cast<uintptr_t>(inf.dli_fbase), GetUniqueId(inf.dli_fbase),
-        base::FilePath(inf.dli_fname));
-    modules->push_back(module);
-    module_index =
-        profile_module_index
-            ->insert(std::make_pair(inf.dli_fbase, modules->size() - 1))
-            .first;
-  }
-  return module_index->second;
-}
-
-// ScopedSuspendThread --------------------------------------------------------
-
-// Suspends a thread for the lifetime of the object.
-class ScopedSuspendThread {
- public:
-  explicit ScopedSuspendThread(mach_port_t thread_port)
-      : thread_port_(thread_suspend(thread_port) == KERN_SUCCESS
-                         ? thread_port
-                         : MACH_PORT_NULL) {}
-
-  ~ScopedSuspendThread() {
-    if (!was_successful())
-      return;
-
-    kern_return_t kr = thread_resume(thread_port_);
-    MACH_CHECK(kr == KERN_SUCCESS, kr) << "thread_resume";
-  }
-
-  bool was_successful() const { return thread_port_ != MACH_PORT_NULL; }
-
- private:
-  mach_port_t thread_port_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedSuspendThread);
-};
-
-// NativeStackSamplerMac ------------------------------------------------------
-
-class NativeStackSamplerMac : public NativeStackSampler {
- public:
-  NativeStackSamplerMac(mach_port_t thread_port,
-                        AnnotateCallback annotator,
-                        NativeStackSamplerTestDelegate* test_delegate);
-  ~NativeStackSamplerMac() override;
-
-  // StackSamplingProfiler::NativeStackSampler:
-  void ProfileRecordingStarting(
-      std::vector<StackSamplingProfiler::Module>* modules) override;
-  void RecordStackSample(StackSamplingProfiler::Sample* sample) override;
-  void ProfileRecordingStopped() override;
-
- private:
-  // Suspends the thread with |thread_port_|, copies its stack and resumes the
-  // thread, then records the stack frames and associated modules into |sample|.
-  void SuspendThreadAndRecordStack(StackSamplingProfiler::Sample* sample);
-
-  // Weak reference: Mach port for thread being profiled.
-  mach_port_t thread_port_;
-
-  const AnnotateCallback annotator_;
-
-  NativeStackSamplerTestDelegate* const test_delegate_;
-
-  // The stack base address corresponding to |thread_handle_|.
-  const void* const thread_stack_base_address_;
-
-  // The size of the |stack_copy_buffer_|.
-  const size_t stack_copy_buffer_size_;
-
-  // Buffer to use for copies of the stack. We use the same buffer for all the
-  // samples to avoid the overhead of multiple allocations and frees.
-  const std::unique_ptr<unsigned char[]> stack_copy_buffer_;
-
-  // Weak. Points to the modules associated with the profile being recorded
-  // between ProfileRecordingStarting() and ProfileRecordingStopped().
-  std::vector<StackSamplingProfiler::Module>* current_modules_ = nullptr;
-
-  // Maps a module's base address to the corresponding Module's index within
-  // current_modules_.
-  std::map<const void*, size_t> profile_module_index_;
-
-  DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerMac);
-};
-
-NativeStackSamplerMac::NativeStackSamplerMac(
-    mach_port_t thread_port,
-    AnnotateCallback annotator,
-    NativeStackSamplerTestDelegate* test_delegate)
-    : thread_port_(thread_port),
-      annotator_(annotator),
-      test_delegate_(test_delegate),
-      thread_stack_base_address_(
-          pthread_get_stackaddr_np(pthread_from_mach_thread_np(thread_port))),
-      stack_copy_buffer_size_(StackCopyBufferSize()),
-      stack_copy_buffer_(new unsigned char[stack_copy_buffer_size_]) {
-  DCHECK(annotator_);
-
-  // This class suspends threads, and those threads might be suspended in dyld.
-  // Therefore, for all the system functions that might be linked in dynamically
-  // that are used while threads are suspended, make calls to them to make sure
-  // that they are linked up.
-  x86_thread_state64_t thread_state;
-  GetThreadState(thread_port_, &thread_state);
-}
-
-NativeStackSamplerMac::~NativeStackSamplerMac() {}
-
-void NativeStackSamplerMac::ProfileRecordingStarting(
-    std::vector<StackSamplingProfiler::Module>* modules) {
-  current_modules_ = modules;
-  profile_module_index_.clear();
-}
-
-void NativeStackSamplerMac::RecordStackSample(
-    StackSamplingProfiler::Sample* sample) {
-  DCHECK(current_modules_);
-
-  SuspendThreadAndRecordStack(sample);
-}
-
-void NativeStackSamplerMac::ProfileRecordingStopped() {
-  current_modules_ = nullptr;
-}
-
-void NativeStackSamplerMac::SuspendThreadAndRecordStack(
-    StackSamplingProfiler::Sample* sample) {
-  x86_thread_state64_t thread_state;
-
-  // Copy the stack.
-
-  uintptr_t new_stack_top = 0;
-  {
-    // IMPORTANT NOTE: Do not do ANYTHING in this in this scope that might
-    // allocate memory, including indirectly via use of DCHECK/CHECK or other
-    // logging statements. Otherwise this code can deadlock on heap locks in the
-    // default heap acquired by the target thread before it was suspended.
-    ScopedSuspendThread suspend_thread(thread_port_);
-    if (!suspend_thread.was_successful())
-      return;
-
-    if (!GetThreadState(thread_port_, &thread_state))
-      return;
-    uintptr_t stack_top =
-        reinterpret_cast<uintptr_t>(thread_stack_base_address_);
-    uintptr_t stack_bottom = thread_state.__rsp;
-    if (stack_bottom >= stack_top)
-      return;
-    uintptr_t stack_size = stack_top - stack_bottom;
-
-    if (stack_size > stack_copy_buffer_size_)
-      return;
-
-    (*annotator_)(sample);
-
-    CopyStackAndRewritePointers(
-        reinterpret_cast<uintptr_t*>(stack_copy_buffer_.get()),
-        reinterpret_cast<uintptr_t*>(stack_bottom),
-        reinterpret_cast<uintptr_t*>(stack_top), &thread_state);
-
-    new_stack_top =
-        reinterpret_cast<uintptr_t>(stack_copy_buffer_.get()) + stack_size;
-  }  // ScopedSuspendThread
-
-  if (test_delegate_)
-    test_delegate_->OnPreStackWalk();
-
-  // Walk the stack and record it.
-
-  // Reserve enough memory for most stacks, to avoid repeated allocations.
-  // Approximately 99.9% of recorded stacks are 128 frames or fewer.
-  sample->frames.reserve(128);
-
-  auto* current_modules = current_modules_;
-  auto* profile_module_index = &profile_module_index_;
-  WalkStack(
-      thread_state, new_stack_top,
-      [sample, current_modules, profile_module_index](uintptr_t frame_ip) {
-        sample->frames.push_back(StackSamplingProfiler::Frame(
-            frame_ip,
-            GetModuleIndex(frame_ip, current_modules, profile_module_index)));
-      });
-}
-
-}  // namespace
-
-std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
-    PlatformThreadId thread_id,
-    AnnotateCallback annotator,
-    NativeStackSamplerTestDelegate* test_delegate) {
-  return base::MakeUnique<NativeStackSamplerMac>(thread_id, annotator,
-                                                 test_delegate);
-}
-
-}  // namespace base