Store frame pointers

src/runtime.cc

 // Copyright 2012 the V8 project 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 <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 11174 matching lines @@
 
 
 static const int kFrameDetailsFrameIdIndex = 0;
 static const int kFrameDetailsReceiverIndex = 1;
 static const int kFrameDetailsFunctionIndex = 2;
 static const int kFrameDetailsArgumentCountIndex = 3;
 static const int kFrameDetailsLocalCountIndex = 4;
 static const int kFrameDetailsSourcePositionIndex = 5;
 static const int kFrameDetailsConstructCallIndex = 6;
 static const int kFrameDetailsAtReturnIndex = 7;
-static const int kFrameDetailsFlagsIndex = 8;
-static const int kFrameDetailsFirstDynamicIndex = 9;
-
+static const int kFrameDetailsFramePointerHighIndex = 8;
+static const int kFrameDetailsFramePointerLowIndex = 9;
+static const int kFrameDetailsFlagsIndex = 10;
+static const int kFrameDetailsFirstDynamicIndex = 11;
 
 static SaveContext* FindSavedContextForFrame(Isolate* isolate,
                                              JavaScriptFrame* frame) {
   SaveContext* save = isolate->save_context();
   while (save != NULL && !save->IsBelowFrame(frame)) {
     save = save->prev();
   }
   ASSERT(save != NULL);
   return save;
 }
 
 
 // Return an array with frame details
 // args[0]: number: break id
 // args[1]: number: frame index
 //
 // The array returned contains the following information:
 // 0: Frame id
 // 1: Receiver
 // 2: Function
 // 3: Argument count
 // 4: Local count
 // 5: Source position
 // 6: Constructor call
 // 7: Is at return
-// 8: Flags
+// 8: Frame pointer high
+// 9: Frame pointer low
+// 10: Flags
 // Arguments name, value
 // Locals name, value
 // Return value if any
 RUNTIME_FUNCTION(Runtime_GetFrameDetails) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
   RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
 
   CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
@@ skipping 164 matching lines @@
   } else {
     details->set(kFrameDetailsSourcePositionIndex, heap->undefined_value());
   }
 
   // Add the constructor information.
   details->set(kFrameDetailsConstructCallIndex, heap->ToBoolean(constructor));
 
   // Add the at return information.
   details->set(kFrameDetailsAtReturnIndex, heap->ToBoolean(at_return));
 
+  uintptr_t frame_pointer =
+      reinterpret_cast<uintptr_t>(it.frame()->UnpaddedFP());
+
+  details->set(kFrameDetailsFramePointerHighIndex,
+      *isolate->factory()->NewNumberFromUint(

[Vyacheslav Egorov (Google), 2014/09/10 22:34:25]

this is GC unsafe in V8, you need to split it into two lines

Handle<...> number = isolate->factory()->NewNumberFromUint(...);
details->set(..., *number);

ditto the next line.

[Jacob, 2014/09/11 00:45:56]

Done.

+          static_cast<uint32_t>(frame_pointer >> 32)));
+  details->set(kFrameDetailsFramePointerLowIndex,
+      *isolate->factory()->NewNumberFromUint(
+          static_cast<uint32_t>(frame_pointer & 0xffffffff)));
+
   // Add flags to indicate information on whether this frame is
   //   bit 0: invoked in the debugger context.
   //   bit 1: optimized frame.
   //   bit 2: inlined in optimized frame
   int flags = 0;
   if (*save->context() == *isolate->debug()->debug_context()) {
     flags |= 1 << 0;
   }
   if (is_optimized) {
     flags |= 1 << 1;
@@ skipping 3803 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal