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 kFrameDetailsFramePointerIndex = 8;
+static const int kFrameDetailsFlagsIndex = 9;
+static const int kFrameDetailsFirstDynamicIndex = 10;
 
 
 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
+// 9: 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));
 
+  // No memory address will actually be larger than 2^48 on a current x64
+  // machine but we truncate to 53 bits to future proof this method. Users
+  // should not care about the exact frame pointer values only the
+  // order of frame pointers. Truncating to 53 bits will still generate the
+  // correct ordering with very high probability.
+  uintptr_t frame_pointer =
+      reinterpret_cast<uintptr_t>(it.frame()->UnpaddedFP()) &
+      ((static_cast<uintptr_t>(1)<<53) - 1);

[hausner, 2014/09/05 18:08:36]

How about building the mask as a const uint64_t value in a separate statement?
Also, what happens when you shift by 53 if you run on 32bit hardware? Can you
omit this address mangling (with ifdefs) when run on a 32bit platform?

+  details->set(kFrameDetailsFramePointerIndex,
+      *isolate->factory()->NewNumber(static_cast<double>(frame_pointer)));
+
   // 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