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"
@@ skipping 23 matching lines @@
 #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 200 matching lines @@
 
 
 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

[srdjan, 2015/05/21 16:06:34]

Or corresponding code for X64

[Cutch, 2015/05/22 01:11:14]

Added a comment about register names on X64.

+  // mov ebp, esp
+  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
+  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 690 matching lines @@
                 exited_dart_code,
                 in_dart_code,
                 sample,
                 &native_stack_walker,
                 &dart_exit_stack_walker,
                 &dart_stack_walker,
                 pc);
 }
 
 }  // namespace dart