[interpreter, debugger] abstraction for source position calculation.

src/debug/debug.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 "src/debug/debug.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 44 matching lines @@
   // occured.
   if (context.is_null()) return v8::Local<v8::Context>();
   Handle<Context> native_context(context->native_context());
   return v8::Utils::ToLocal(native_context);
 }
 
 
 BreakLocation::BreakLocation(Handle<DebugInfo> debug_info, RelocInfo* rinfo,
                              int position, int statement_position)
     : debug_info_(debug_info),
-      pc_offset_(static_cast<int>(rinfo->pc() - debug_info->code()->entry())),
+      code_offset_(static_cast<int>(rinfo->pc() - debug_info->code()->entry())),
       rmode_(rinfo->rmode()),
       data_(rinfo->data()),
       position_(position),
       statement_position_(statement_position) {}
 
 
 BreakLocation::Iterator::Iterator(Handle<DebugInfo> debug_info,
                                   BreakLocatorType type)
     : debug_info_(debug_info),
       reloc_iterator_(debug_info->code(), GetModeMask(type)),
@@ skipping 61 matching lines @@
     }
 
     break;
   }
   break_index_++;
 }
 
 
 // Find the break point at the supplied address, or the closest one before
 // the address.
-BreakLocation BreakLocation::FromAddress(Handle<DebugInfo> debug_info,
-                                         Address pc) {
+BreakLocation BreakLocation::FromCodeOffset(Handle<DebugInfo> debug_info,
+                                            int offset) {
   Iterator it(debug_info, ALL_BREAK_LOCATIONS);
-  it.SkipTo(BreakIndexFromAddress(debug_info, pc));
+  it.SkipTo(BreakIndexFromCodeOffset(debug_info, offset));
   return it.GetBreakLocation();
 }
 
 
+BreakLocation BreakLocation::FromFrame(Handle<DebugInfo> debug_info,
+                                       JavaScriptFrame* frame) {
+  // Code offset to the instruction after the current one, possibly a break
+  // location as well. So the "- 1" to exclude it from the search.
+  Code* code = frame->LookupCode();
+  int code_offset = frame->pc() - code->instruction_start();
+  return FromCodeOffset(debug_info, code_offset - 1);
+}
+
+
 // Find the break point at the supplied address, or the closest one before
 // the address.
-void BreakLocation::FromAddressSameStatement(Handle<DebugInfo> debug_info,
-                                             Address pc,
-                                             List<BreakLocation>* result_out) {
-  int break_index = BreakIndexFromAddress(debug_info, pc);
+void BreakLocation::FromCodeOffsetSameStatement(
+    Handle<DebugInfo> debug_info, int offset, List<BreakLocation>* result_out) {
+  int break_index = BreakIndexFromCodeOffset(debug_info, offset);
   Iterator it(debug_info, ALL_BREAK_LOCATIONS);
   it.SkipTo(break_index);
   int statement_position = it.statement_position();
   while (!it.Done() && it.statement_position() == statement_position) {
     result_out->Add(it.GetBreakLocation());
     it.Next();
   }
 }
 
 
-int BreakLocation::BreakIndexFromAddress(Handle<DebugInfo> debug_info,
-                                         Address pc) {
+int BreakLocation::BreakIndexFromCodeOffset(Handle<DebugInfo> debug_info,
+                                            int offset) {
   // Run through all break points to locate the one closest to the address.
   int closest_break = 0;
   int distance = kMaxInt;
+  Code* code = debug_info->code();
+  DCHECK(0 <= offset && offset < code->instruction_size());
+  Address pc = debug_info->code()->instruction_start() + offset;
   for (Iterator it(debug_info, ALL_BREAK_LOCATIONS); !it.Done(); it.Next()) {
     // Check if this break point is closer that what was previously found.
     if (it.pc() <= pc && pc - it.pc() < distance) {
       closest_break = it.break_index();
       distance = static_cast<int>(pc - it.pc());
       // Check whether we can't get any closer.
       if (distance == 0) break;
     }
   }
   return closest_break;
@@ skipping 29 matching lines @@
   return it.GetBreakLocation();
 }
 
 
 void BreakLocation::SetBreakPoint(Handle<Object> break_point_object) {
   // If there is not already a real break point here patch code with debug
   // break.
   if (!HasBreakPoint()) SetDebugBreak();
   DCHECK(IsDebugBreak() || IsDebuggerStatement());
   // Set the break point information.
-  DebugInfo::SetBreakPoint(debug_info_, pc_offset_, position_,
+  DebugInfo::SetBreakPoint(debug_info_, code_offset_, position_,
                            statement_position_, break_point_object);
 }
 
 
 void BreakLocation::ClearBreakPoint(Handle<Object> break_point_object) {
   // Clear the break point information.
-  DebugInfo::ClearBreakPoint(debug_info_, pc_offset_, break_point_object);
+  DebugInfo::ClearBreakPoint(debug_info_, code_offset_, break_point_object);
   // If there are no more break points here remove the debug break.
   if (!HasBreakPoint()) {
     ClearDebugBreak();
     DCHECK(!IsDebugBreak());
   }
 }
 
 
 void BreakLocation::SetOneShot() {
   // Debugger statement always calls debugger. No need to modify it.
@@ skipping 57 matching lines @@
 
 
 bool BreakLocation::IsDebugBreak() const {
   if (IsDebuggerStatement()) return false;
   DCHECK(IsDebugBreakSlot());
   return rinfo().IsPatchedDebugBreakSlotSequence();
 }
 
 
 Handle<Object> BreakLocation::BreakPointObjects() const {
-  return debug_info_->GetBreakPointObjects(pc_offset_);
+  return debug_info_->GetBreakPointObjects(code_offset_);
 }
 
 
 void DebugFeatureTracker::Track(DebugFeatureTracker::Feature feature) {
   uint32_t mask = 1 << feature;
   // Only count one sample per feature and isolate.
   if (bitfield_ & mask) return;
   isolate_->counters()->debug_feature_usage()->AddSample(feature);
   bitfield_ |= mask;
 }
@@ skipping 356 matching lines @@
   DebugInfoListNode* node = debug_info_list_;
   while (node != NULL) {
     Handle<Object> result =
         DebugInfo::FindBreakPointInfo(node->debug_info(), break_point_object);
     if (!result->IsUndefined()) {
       // Get information in the break point.
       Handle<BreakPointInfo> break_point_info =
           Handle<BreakPointInfo>::cast(result);
       Handle<DebugInfo> debug_info = node->debug_info();
 
-      // Find the break point and clear it.
-      Address pc =
-          debug_info->code()->entry() + break_point_info->code_position();
-
-      BreakLocation location = BreakLocation::FromAddress(debug_info, pc);
+      BreakLocation location = BreakLocation::FromCodeOffset(
+          debug_info, break_point_info->code_offset());
       location.ClearBreakPoint(break_point_object);
 
       // If there are no more break points left remove the debug info for this
       // function.
       if (debug_info->GetBreakPointCount() == 0) {
         RemoveDebugInfoAndClearFromShared(debug_info);
       }
 
       return;
     }
@@ skipping 150 matching lines @@
   FrameSummary summary = GetFirstFrameSummary(frame);
   Handle<JSFunction> function(summary.function());
   Handle<SharedFunctionInfo> shared(function->shared());
   if (!EnsureDebugInfo(shared, function)) {
     // Return if ensuring debug info failed.
     return;
   }
 
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   // Refresh frame summary if the code has been recompiled for debugging.
-  if (shared->code() != *summary.code()) summary = GetFirstFrameSummary(frame);
+  if (shared->AbstractCode() != *summary.abstract_code()) {
+    summary = GetFirstFrameSummary(frame);
+  }
 
   // PC points to the instruction after the current one, possibly a break
   // location as well. So the "- 1" to exclude it from the search.
-  BreakLocation location = BreakLocation::FromFrame(debug_info, &summary);
+  BreakLocation location =
+      BreakLocation::FromCodeOffset(debug_info, summary.code_offset() - 1);
 
   // At a return statement we will step out either way.
   if (location.IsReturn()) step_action = StepOut;
 
+  Address pc = debug_info->code()->instruction_start() + summary.code_offset();
   thread_local_.last_statement_position_ =
-      debug_info->code()->SourceStatementPosition(summary.pc());
+      debug_info->code()->SourceStatementPosition(pc);
   thread_local_.last_fp_ = frame->UnpaddedFP();
 
   switch (step_action) {
     case StepNone:
       UNREACHABLE();
       break;
     case StepOut:
       // Advance to caller frame.
       frames_it.Advance();
       // Skip native and extension functions on the stack.
@@ skipping 591 matching lines @@
                                List<int>* results_out) {
   FrameSummary summary = GetFirstFrameSummary(frame);
 
   Handle<JSFunction> fun = Handle<JSFunction>(summary.function());
   Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>(fun->shared());
 
   if (!EnsureDebugInfo(shared, fun)) return;
 
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   // Refresh frame summary if the code has been recompiled for debugging.
-  if (shared->code() != *summary.code()) summary = GetFirstFrameSummary(frame);
+  if (shared->AbstractCode() != *summary.abstract_code()) {
+    summary = GetFirstFrameSummary(frame);
+  }
 
   // Find range of break points starting from the break point where execution
   // has stopped.

[rmcilroy, 2016/01/22 19:16:34]

Nit - could you add a comment on the -1 here too.

[Yang, 2016/01/28 09:09:53]

Done.

-  Address call_pc = summary.pc() - 1;
+  int call_offset = summary.code_offset() - 1;
   List<BreakLocation> locations;
-  BreakLocation::FromAddressSameStatement(debug_info, call_pc, &locations);
+  BreakLocation::FromCodeOffsetSameStatement(debug_info, call_offset,
+                                             &locations);
 
   for (BreakLocation location : locations) {
-    if (location.pc() <= summary.pc()) {
+    if (location.code_offset() <= summary.code_offset()) {
       // The break point is near our pc. Could be a step-in possibility,
       // that is currently taken by active debugger call.
       if (break_frame_id() == StackFrame::NO_ID) {
         continue;  // We are not stepping.
       } else {
         JavaScriptFrameIterator frame_it(isolate_, break_frame_id());
         // If our frame is a top frame and we are stepping, we can do step-in
         // at this place.
         if (frame_it.frame()->id() != frame_id) continue;
       }
@@ skipping 923 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8