Track prologue offset of Code and use for more precise return addresses

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
 #include "vm/code_patcher.h"
 #include "vm/instructions.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/signal_handler.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
 
+DECLARE_FLAG(bool, trace_profiler);
+
 DEFINE_FLAG(bool, profile, true, "Enable Sampling Profiler");
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
+
 #if defined(TARGET_OS_ANDROID) || defined(TARGET_ARCH_ARM64) ||                \
     defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_MIPS)
   DEFINE_FLAG(int, profile_period, 10000,
               "Time between profiler samples in microseconds. Minimum 50.");
 #else
   DEFINE_FLAG(int, profile_period, 1000,
               "Time between profiler samples in microseconds. Minimum 50.");
 #endif
 DEFINE_FLAG(int, profile_depth, 8,
             "Maximum number stack frames walked. Minimum 1. Maximum 255.");
 #if defined(USING_SIMULATOR)
 DEFINE_FLAG(bool, profile_vm, true,
             "Always collect native stack traces.");
 #else
-DEFINE_FLAG(bool, profile_vm, true,
+DEFINE_FLAG(bool, profile_vm, false,
             "Always collect native stack traces.");
 #endif
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
 static intptr_t NumberOfFramesToCollect() {
   if (FLAG_profile_depth <= 0) {
     return 0;
   }
@@ skipping 178 matching lines @@
 uword* Sample::GetPCArray() const {
   return reinterpret_cast<uword*>(
         reinterpret_cast<uintptr_t>(this) + sizeof(*this));
 }
 
 
 SampleBuffer::SampleBuffer(intptr_t capacity) {
   ASSERT(Sample::instance_size() > 0);
   samples_ = reinterpret_cast<Sample*>(
       calloc(capacity, Sample::instance_size()));
+  if (FLAG_trace_profiler) {
+    OS::Print("Profiler holds %" Pd " samples\n", capacity);
+    OS::Print("Profiler sample is %" Pd " bytes\n", Sample::instance_size());
+    OS::Print("Profiler memory usage = %" Pd " bytes\n",
+              capacity * Sample::instance_size());
+  }
   capacity_ = capacity;
   cursor_ = 0;
 }
 
 
 Sample* SampleBuffer::At(intptr_t idx) const {
   ASSERT(idx >= 0);
   ASSERT(idx < capacity_);
   intptr_t offset = idx * Sample::instance_size();
   uint8_t* samples = reinterpret_cast<uint8_t*>(samples_);
   return reinterpret_cast<Sample*>(samples + offset);
 }
 
 
 Sample* SampleBuffer::ReserveSample() {
   ASSERT(samples_ != NULL);
   uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
   // Map back into sample buffer range.
   cursor = cursor % capacity_;
   return At(cursor);
 }
 
-
 // Attempts to find the true return address when a Dart frame is being setup
 // or torn down.
 // NOTE: Architecture specific implementations below.
 class ReturnAddressLocator : public ValueObject {
  public:
   ReturnAddressLocator(Sample* sample, const Code& code)
       : sample_(sample),
-        code_(Code::ZoneHandle(code.raw())),
-        is_optimized_(code.is_optimized()) {
+        code_(Code::ZoneHandle(code.raw())) {
     ASSERT(!code_.IsNull());
     ASSERT(code_.ContainsInstructionAt(pc()));
   }
 
-  bool is_code_optimized() {
-    return is_optimized_;
-  }
-
   uword pc() {
     return sample_->pc();
   }
 
   // Returns false on failure.
   bool LocateReturnAddress(uword* return_address);
 
   // Returns offset into code object.
-  uword RelativePC() {
-    return pc() - code_.EntryPoint();
+  intptr_t RelativePC() {
+    ASSERT(pc() >= code_.EntryPoint());
+    return static_cast<intptr_t>(pc() - code_.EntryPoint());
   }
 
-  uint8_t* CodePointer(uword offset) {
-    const uword size = code_.Size();
+  uint8_t* CodePointer(intptr_t offset) {
+    const intptr_t size = code_.Size();
     ASSERT(offset < size);
     uint8_t* code_pointer = reinterpret_cast<uint8_t*>(code_.EntryPoint());
     code_pointer += offset;
     return code_pointer;
   }
 
   uword StackAt(intptr_t i) {
     ASSERT(i >= 0);
     ASSERT(i < Sample::kStackBufferSizeInWords);
     return sample_->GetStackBuffer()[i];
   }
 
  private:
   Sample* sample_;
   const Code& code_;
-  const bool is_optimized_;
 };
 
 
-#if defined(TARGET_ARCH_IA32)
+#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 bool ReturnAddressLocator::LocateReturnAddress(uword* return_address) {
   ASSERT(return_address != NULL);
-  const uword offset = RelativePC();
-  const uword size = code_.Size();
-  if (is_optimized_) {
-    // 0: push ebp
-    // 1: mov ebp, esp
-    // 3: ...
-    if (offset == 0x0) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    if (offset == 0x1) {
-      // Stack layout:
-      // 0 CALLER FRAME POINTER
-      // 1 RETURN ADDRESS
-      *return_address = StackAt(1);
-      return true;
-    }
-    ReturnPattern rp(pc());
-    if (rp.IsValid()) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    return false;
-  } else {
-    // 0x00: mov edi, function
-    // 0x05: incl (inc usage count)   <-- this is optional.
-    // 0x08: cmpl (compare usage count)
-    // 0x0f: jump to optimize function
-    // 0x15: push ebp
-    // 0x16: mov ebp, esp
-    // 0x18: ...
-    ASSERT(size >= 0x08);
-    const uword incl_offset = 0x05;
-    const uword incl_length = 0x03;
-    const uint8_t incl_op_code = 0xFF;
-    const bool has_incl = (*CodePointer(incl_offset) == incl_op_code);
-    const uword push_fp_offset = has_incl ? 0x15 : 0x15 - incl_length;
-    if (offset <= push_fp_offset) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    if (offset == (push_fp_offset + 1)) {
-      // Stack layout:
-      // 0 CALLER FRAME POINTER
-      // 1 RETURN ADDRESS
-      *return_address = StackAt(1);
-      return true;
-    }
-    ReturnPattern rp(pc());
-    if (rp.IsValid()) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    return false;
+  const intptr_t offset = RelativePC();
+  ASSERT(offset >= 0);
+  const intptr_t size = code_.Size();
+  ASSERT(offset < size);
+  const intptr_t prologue_offset = code_.GetPrologueOffset();
+  if (offset < prologue_offset) {
+    // Before the prologue, return address is at the top of the stack.
+    // TODO(johnmccutchan): Some intrinsics and stubs do not conform to the
+    // expected stack layout. Use a more robust solution for those code objects.
+    *return_address = StackAt(0);
+    return true;
   }
-  UNREACHABLE();
-  return false;
-}
-#elif defined(TARGET_ARCH_X64)
-bool ReturnAddressLocator::LocateReturnAddress(uword* return_address) {
-  ASSERT(return_address != NULL);
-  const uword offset = RelativePC();
-  const uword size = code_.Size();
-  if (is_optimized_) {
-    // 0x00: leaq (load pc marker)
-    // 0x07: movq (load pool pointer)
-    // 0x0c: push rpb
-    // 0x0d: movq rbp, rsp
-    // 0x10: ...
-    const uword push_fp_offset = 0x0c;
-    if (offset <= push_fp_offset) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    if (offset == (push_fp_offset + 1)) {
-      // Stack layout:
-      // 0 CALLER FRAME POINTER
-      // 1 RETURN ADDRESS
-      *return_address = StackAt(1);
-      return true;
-    }
-    ReturnPattern rp(pc());
-    if (rp.IsValid()) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    return false;
-  } else {
-    // 0x00: leaq (load pc marker)
-    // 0x07: movq (load pool pointer)
-    // 0x0c: movq (load function)
-    // 0x13: incl (inc usage count)   <-- this is optional.
-    // 0x16: cmpl (compare usage count)
-    // 0x1d: jl + 0x
-    // 0x23: jmp [pool pointer]
-    // 0x27: push rbp
-    // 0x28: movq rbp, rsp
-    // 0x2b: ...
-    ASSERT(size >= 0x16);
-    const uword incl_offset = 0x13;
-    const uword incl_length = 0x03;
-    const uint8_t incl_op_code = 0xFF;
-    const bool has_incl = (*CodePointer(incl_offset) == incl_op_code);
-    const uword push_fp_offset = has_incl ? 0x27 : 0x27 - incl_length;
-    if (offset <= push_fp_offset) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    if (offset == (push_fp_offset + 1)) {
-      // Stack layout:
-      // 0 CALLER FRAME POINTER
-      // 1 RETURN ADDRESS
-      *return_address = StackAt(1);
-      return true;
-    }
-    ReturnPattern rp(pc());
-    if (rp.IsValid()) {
-      // Stack layout:
-      // 0 RETURN ADDRESS.
-      *return_address = StackAt(0);
-      return true;
-    }
-    return false;
+  // Detect if we are:
+  // push ebp      <--- here
+  // mov ebp, esp
+  // on X64 the register names are different but the sequence is the same.
+  ProloguePattern pp(pc());
+  if (pp.IsValid()) {
+    // Stack layout:
+    // 0 RETURN ADDRESS.
+    *return_address = StackAt(0);
+    return true;
   }
-  UNREACHABLE();
+  // Detect if we are:
+  // push ebp
+  // mov ebp, esp  <--- here
+  // on X64 the register names are different but the sequence is the same.
+  SetFramePointerPattern sfpp(pc());
+  if (sfpp.IsValid()) {
+    // Stack layout:
+    // 0 CALLER FRAME POINTER
+    // 1 RETURN ADDRESS
+    *return_address = StackAt(1);
+    return true;
+  }
+  // Detect if we are:
+  // ret           <--- here
+  ReturnPattern rp(pc());
+  if (rp.IsValid()) {
+    // Stack layout:
+    // 0 RETURN ADDRESS.
+    *return_address = StackAt(0);
+    return true;
+  }
   return false;
 }
 #elif defined(TARGET_ARCH_ARM)
 bool ReturnAddressLocator::LocateReturnAddress(uword* return_address) {
   ASSERT(return_address != NULL);
   return false;
 }
 #elif defined(TARGET_ARCH_ARM64)
 bool ReturnAddressLocator::LocateReturnAddress(uword* return_address) {
   ASSERT(return_address != NULL);
@@ skipping 63 matching lines @@
   ASSERT(!code.IsNull());
 
   // The pc marker is our current best guess of a return address.
   uword return_address = sample->pc_marker();
 
   // Attempt to find a better return address.
   ReturnAddressLocator ral(sample, code);
 
   if (!ral.LocateReturnAddress(&return_address)) {
     ASSERT(return_address == sample->pc_marker());
+    if (code.GetPrologueOffset() == 0) {
+      // Code has the prologue at offset 0. The frame is already setup and
+      // can be trusted.
+      return;
+    }
     // Could not find a better return address than the pc_marker.
     if (code.ContainsInstructionAt(return_address)) {
       // PC marker is in the same code as pc, no missing frame.
       return;
     }
   }
 
   if (!ContainedInDartCodeHeaps(return_address)) {
     // return address is not from the Dart heap. Do not insert.
     return;
@@ skipping 34 matching lines @@
 }
 
 
 // Given an exit frame, walk the Dart stack.
 class ProfilerDartExitStackWalker : public ValueObject {
  public:
   ProfilerDartExitStackWalker(Isolate* isolate, Sample* sample)
       : sample_(sample),
         frame_iterator_(isolate) {
     ASSERT(sample_ != NULL);
-    // Mark that this sample was collected from an exit frame.
-    sample_->set_exit_frame_sample(true);
   }
 
   void walk() {
+    // Mark that this sample was collected from an exit frame.
+    sample_->set_exit_frame_sample(true);
     intptr_t frame_index = 0;
     StackFrame* frame = frame_iterator_.NextFrame();
     while (frame != NULL) {
       sample_->SetAt(frame_index, frame->pc());
       frame_index++;
       if (frame_index >= NumberOfFramesToCollect()) {
         sample_->set_truncated_trace(true);
         break;
       }
       frame = frame_iterator_.NextFrame();
@@ skipping 20 matching lines @@
         sample_(sample),
         stack_upper_(stack_upper),
         stack_lower_(stack_lower) {
     ASSERT(sample_ != NULL);
     pc_ = reinterpret_cast<uword*>(pc);
     fp_ = reinterpret_cast<uword*>(fp);
     sp_ = reinterpret_cast<uword*>(sp);
   }
 
   void walk() {
+    sample_->set_exit_frame_sample(false);
     if (!ValidFramePointer()) {
       sample_->set_ignore_sample(true);
       return;
     }
     ASSERT(ValidFramePointer());
     uword return_pc = InitialReturnAddress();
     if (StubCode::InInvocationStubForIsolate(isolate_, return_pc)) {
       // Edge case- we have called out from the Invocation Stub but have not
       // created the stack frame of the callee. Attempt to locate the exit
       // frame before walking the stack.
@@ skipping 508 matching lines @@
                 exited_dart_code,
                 in_dart_code,
                 sample,
                 &native_stack_walker,
                 &dart_exit_stack_walker,
                 &dart_stack_walker,
                 pc);
 }
 
 }  // namespace dart