[interpreter, debugger] abstraction for source position calculation.

src/debug/debug.h

 // 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.
 
 #ifndef V8_DEBUG_DEBUG_H_
 #define V8_DEBUG_DEBUG_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/assembler.h"
@@ skipping 46 matching lines @@
 enum BreakPositionAlignment {
   STATEMENT_ALIGNED = 0,
   BREAK_POSITION_ALIGNED = 1
 };
 
 
 class BreakLocation {
  public:
   // Find the break point at the supplied address, or the closest one before
   // the address.
-  static BreakLocation FromAddress(Handle<DebugInfo> debug_info, Address pc);
+  static BreakLocation FromCodeOffset(Handle<DebugInfo> debug_info, int offset);
 
-  template <class Frame>
-  static BreakLocation FromFrame(Handle<DebugInfo> debug_info, Frame* 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.
-    return FromAddress(debug_info, frame->pc() - 1);
-  }
+  static BreakLocation FromFrame(Handle<DebugInfo> debug_info,
+                                 JavaScriptFrame* frame);
 
-  static void FromAddressSameStatement(Handle<DebugInfo> debug_info, Address pc,
-                                       List<BreakLocation>* result_out);
+  static void FromCodeOffsetSameStatement(Handle<DebugInfo> debug_info,
+                                          int offset,
+                                          List<BreakLocation>* result_out);
 
   static BreakLocation FromPosition(Handle<DebugInfo> debug_info, int position,
                                     BreakPositionAlignment alignment);
 
   bool IsDebugBreak() const;
 
   inline bool IsReturn() const {
     return RelocInfo::IsDebugBreakSlotAtReturn(rmode_);
   }
   inline bool IsCall() const {
     return RelocInfo::IsDebugBreakSlotAtCall(rmode_);
   }
   inline bool HasBreakPoint() const {
-    return debug_info_->HasBreakPoint(pc_offset_);
+    return debug_info_->HasBreakPoint(code_offset_);
   }
 
   Handle<Object> BreakPointObjects() const;
 
   void SetBreakPoint(Handle<Object> break_point_object);
   void ClearBreakPoint(Handle<Object> break_point_object);
 
   void SetOneShot();
   void ClearOneShot();
 
 
   inline RelocInfo rinfo() const {
     return RelocInfo(debug_info_->GetIsolate(), pc(), rmode(), data_, code());
   }
 
   inline int position() const { return position_; }
   inline int statement_position() const { return statement_position_; }
 
-  inline Address pc() const { return code()->entry() + pc_offset_; }
+  inline int code_offset() const { return code_offset_; }
 
   inline RelocInfo::Mode rmode() const { return rmode_; }
 
   inline Code* code() const { return debug_info_->code(); }
 
  private:
   BreakLocation(Handle<DebugInfo> debug_info, RelocInfo* rinfo, int position,
                 int statement_position);
 
   class Iterator {
@@ skipping 28 matching lines @@
     int position_;
     int statement_position_;
 
     DisallowHeapAllocation no_gc_;
 
     DISALLOW_COPY_AND_ASSIGN(Iterator);
   };
 
   friend class Debug;
 
-  static int BreakIndexFromAddress(Handle<DebugInfo> debug_info, Address pc);
+  static int BreakIndexFromCodeOffset(Handle<DebugInfo> debug_info, int offset);
 
   void SetDebugBreak();
   void ClearDebugBreak();
 
   inline bool IsDebuggerStatement() const {
     return RelocInfo::IsDebuggerStatement(rmode_);
   }
   inline bool IsDebugBreakSlot() const {
     return RelocInfo::IsDebugBreakSlot(rmode_);
   }
 
+  inline Address pc() const { return code()->entry() + code_offset_; }
+
   Handle<DebugInfo> debug_info_;
-  int pc_offset_;
+  int code_offset_;
   RelocInfo::Mode rmode_;
   intptr_t data_;
   int position_;
   int statement_position_;
 };
 
 
 // Linked list holding debug info objects. The debug info objects are kept as
 // weak handles to avoid a debug info object to keep a function alive.
 class DebugInfoListNode {
@@ skipping 565 matching lines @@
   static void PatchDebugBreakSlot(Isolate* isolate, Address pc,
                                   Handle<Code> code);
   static void ClearDebugBreakSlot(Isolate* isolate, Address pc);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_H_