Support for return-address rewriting profilers.

src/frames.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 23 matching lines @@
 #include "mark-compact.h"
 #include "safepoint-table.h"
 #include "scopeinfo.h"
 #include "string-stream.h"
 
 #include "allocation-inl.h"
 
 namespace v8 {
 namespace internal {
 
+
+ReturnAddressLocationResolver return_address_location_resolver = NULL;

[Vyacheslav Egorov (Chromium), 2012/02/24 10:34:02]

declare it static

[Sigurður Ásgeirsson, 2012/02/24 14:46:04]

Done.

+
+
+// Resolves pc_address through the resolution address function if one is set.
+Address* ResolveReturnAddressLocation(Address* pc_address) {

[Vyacheslav Egorov (Chromium), 2012/02/24 10:34:02]

declare it static

[Sigurður Ásgeirsson, 2012/02/24 14:46:04]

Done.
Does this warrant "static inline" or are the compilers we use generally smart
enough to work that out for themselves?

[Vyacheslav Egorov (Chromium), 2012/02/24 14:48:21]

Yes, I think there is no harm declaring it inline (though these days it serves
more as a way to communicate our "hope of inlining" to other code readers than
to compiler).

[Sigurður Ásgeirsson, 2012/02/24 14:59:40]

Done.

+  if (return_address_location_resolver == NULL) {
+    return pc_address;
+  } else {
+    return reinterpret_cast<Address*>(
+        return_address_location_resolver(
+            reinterpret_cast<uintptr_t>(pc_address)));
+        }
+}
+
+
 // Iterator that supports traversing the stack handlers of a
 // particular frame. Needs to know the top of the handler chain.
 class StackHandlerIterator BASE_EMBEDDED {
  public:
   StackHandlerIterator(const StackFrame* frame, StackHandler* handler)
       : limit_(frame->fp()), handler_(handler) {
     // Make sure the handler has already been unwound to this frame.
     ASSERT(frame->sp() <= handler->address());
   }
 
@@ skipping 94 matching lines @@
   StackFrame::Type type;
   if (thread_ != NULL) {
     type = ExitFrame::GetStateForFramePointer(
         Isolate::c_entry_fp(thread_), &state);
     handler_ = StackHandler::FromAddress(
         Isolate::handler(thread_));
   } else {
     ASSERT(fp_ != NULL);
     state.fp = fp_;
     state.sp = sp_;
-    state.pc_address =
-        reinterpret_cast<Address*>(StandardFrame::ComputePCAddress(fp_));
+    state.pc_address = ResolveReturnAddressLocation(
+        reinterpret_cast<Address*>(StandardFrame::ComputePCAddress(fp_)));
     type = StackFrame::ComputeType(isolate(), &state);
   }
   if (SingletonFor(type) == NULL) return;
   frame_ = SingletonFor(type, &state);
 }
 
 
 StackFrame* StackFrameIterator::SingletonFor(StackFrame::Type type,
                                              StackFrame::State* state) {
   if (type == StackFrame::NONE) return NULL;
@@ skipping 235 matching lines @@
   ASSERT(GcSafeCodeContains(holder, pc));
   unsigned pc_offset = static_cast<unsigned>(pc - holder->instruction_start());
   Object* code = holder;
   v->VisitPointer(&code);
   if (code != holder) {
     holder = reinterpret_cast<Code*>(code);
     pc = holder->instruction_start() + pc_offset;
     *pc_address = pc;
   }
 }
 

[Vyacheslav Egorov (Chromium), 2012/02/24 10:34:02]

add empty line

[Sigurður Ásgeirsson, 2012/02/24 14:46:04]

Done.

+void StackFrame::SetReturnAddressLocationResolver(
+    ReturnAddressLocationResolver resolver) {
+  return_address_location_resolver = resolver;

[Vyacheslav Egorov (Chromium), 2012/02/24 10:34:02]

assert that we don't have any other resolver installed.

[Sigurður Ásgeirsson, 2012/02/24 14:46:04]

Done.

+}
+
 
 StackFrame::Type StackFrame::ComputeType(Isolate* isolate, State* state) {
   ASSERT(state->fp != NULL);
   if (StandardFrame::IsArgumentsAdaptorFrame(state->fp)) {
     return ARGUMENTS_ADAPTOR;
   }
   // The marker and function offsets overlap. If the marker isn't a
   // smi then the frame is a JavaScript frame -- and the marker is
   // really the function.
   const int offset = StandardFrameConstants::kMarkerOffset;
@@ skipping 55 matching lines @@
 
 Code* ExitFrame::unchecked_code() const {
   return reinterpret_cast<Code*>(code_slot());
 }
 
 
 void ExitFrame::ComputeCallerState(State* state) const {
   // Set up the caller state.
   state->sp = caller_sp();
   state->fp = Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset);
-  state->pc_address
-      = reinterpret_cast<Address*>(fp() + ExitFrameConstants::kCallerPCOffset);
+  state->pc_address = ResolveReturnAddressLocation(
+      reinterpret_cast<Address*>(fp() + ExitFrameConstants::kCallerPCOffset));
 }
 
 
 void ExitFrame::SetCallerFp(Address caller_fp) {
   Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset) = caller_fp;
 }
 
 
 void ExitFrame::Iterate(ObjectVisitor* v) const {
   // The arguments are traversed as part of the expression stack of
@@ skipping 13 matching lines @@
   Address sp = ComputeStackPointer(fp);
   FillState(fp, sp, state);
   ASSERT(*state->pc_address != NULL);
   return EXIT;
 }
 
 
 void ExitFrame::FillState(Address fp, Address sp, State* state) {
   state->sp = sp;
   state->fp = fp;
-  state->pc_address = reinterpret_cast<Address*>(sp - 1 * kPointerSize);
+  state->pc_address = ResolveReturnAddressLocation(
+      reinterpret_cast<Address*>(sp - 1 * kPointerSize));
 }
 
 
 Address StandardFrame::GetExpressionAddress(int n) const {
   const int offset = StandardFrameConstants::kExpressionsOffset;
   return fp() + offset - n * kPointerSize;
 }
 
 
 Object* StandardFrame::GetExpression(Address fp, int index) {
@@ skipping 14 matching lines @@
   Address limit = sp();
   ASSERT(base >= limit);  // stack grows downwards
   // Include register-allocated locals in number of expressions.
   return static_cast<int>((base - limit) / kPointerSize);
 }
 
 
 void StandardFrame::ComputeCallerState(State* state) const {
   state->sp = caller_sp();
   state->fp = caller_fp();
-  state->pc_address = reinterpret_cast<Address*>(ComputePCAddress(fp()));
+  state->pc_address = ResolveReturnAddressLocation(
+      reinterpret_cast<Address*>(ComputePCAddress(fp())));
 }
 
 
 void StandardFrame::SetCallerFp(Address caller_fp) {
   Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset) =
       caller_fp;
 }
 
 
 bool StandardFrame::IsExpressionInsideHandler(int n) const {
@@ skipping 818 matching lines @@
   ZoneList<StackFrame*> list(10);
   for (StackFrameIterator it; !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame());
     list.Add(frame);
   }
   return list.ToVector();
 }
 
 
 } }  // namespace v8::internal