[interpreter, debugger] implement bytecode break location iterator.

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"
 #include "src/base/atomicops.h"
 #include "src/base/platform/platform.h"
 #include "src/debug/liveedit.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/flags.h"
 #include "src/frames.h"
 #include "src/hashmap.h"
+#include "src/interpreter/source-position-table.h"
 #include "src/runtime/runtime.h"
 #include "src/string-stream.h"
 #include "src/v8threads.h"
 
 #include "include/v8-debug.h"
 
 namespace v8 {
 namespace internal {
 
 
@@ skipping 48 matching lines @@
                                       int statement_position,
                                       List<BreakLocation>* result_out);
 
   static BreakLocation FromPosition(Handle<DebugInfo> debug_info, int position,
                                     BreakPositionAlignment alignment);
 
   bool IsDebugBreak() const;
 
   inline bool IsReturn() const { return type_ == DEBUG_BREAK_SLOT_AT_RETURN; }
   inline bool IsCall() const { return type_ == DEBUG_BREAK_SLOT_AT_CALL; }
+  inline bool IsDebugBreakSlot() const { return type_ >= DEBUG_BREAK_SLOT; }
+  inline bool IsDebuggerStatement() const {
+    return type_ == DEBUGGER_STATEMENT;
+  }
   inline bool HasBreakPoint() const {
     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 int position() const { return position_; }
   inline int statement_position() const { return statement_position_; }
 
   inline int code_offset() const { return code_offset_; }
   inline Isolate* isolate() { return debug_info_->GetIsolate(); }
 
   inline AbstractCode* abstract_code() const {
     return debug_info_->abstract_code();
   }
 
- private:
+ protected:
   enum DebugBreakType {
     NOT_DEBUG_BREAK,
     DEBUGGER_STATEMENT,
     DEBUG_BREAK_SLOT,
     DEBUG_BREAK_SLOT_AT_CALL,
     DEBUG_BREAK_SLOT_AT_RETURN
   };
 
   BreakLocation(Handle<DebugInfo> debug_info, DebugBreakType type,
                 int code_offset, int position, int statement_position);
 
   class Iterator {
    public:
     virtual ~Iterator() {}
 
     virtual BreakLocation GetBreakLocation() = 0;
     virtual bool Done() const = 0;
     virtual void Next() = 0;
 
     void SkipTo(int count) {
       while (count-- > 0) Next();
     }
 
     virtual int code_offset() = 0;
     int break_index() const { return break_index_; }
     inline int position() const { return position_; }
     inline int statement_position() const { return statement_position_; }
 
    protected:
-    Iterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
+    explicit Iterator(Handle<DebugInfo> debug_info);
 
     Handle<DebugInfo> debug_info_;
     int break_index_;
     int position_;
     int statement_position_;
 
    private:
     DisallowHeapAllocation no_gc_;
     DISALLOW_COPY_AND_ASSIGN(Iterator);
   };
 
   class CodeIterator : public Iterator {
    public:
     CodeIterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
-    ~CodeIterator() override{};
+    ~CodeIterator() override {}
 
     BreakLocation GetBreakLocation() override;
     bool Done() const override { return reloc_iterator_.done(); }
     void Next() override;
 
     int code_offset() override {
       return static_cast<int>(
           rinfo()->pc() -
           debug_info_->abstract_code()->GetCode()->instruction_start());
     }
 
    private:
     static int GetModeMask(BreakLocatorType type);
     RelocInfo::Mode rmode() { return reloc_iterator_.rinfo()->rmode(); }
     RelocInfo* rinfo() { return reloc_iterator_.rinfo(); }
 
     RelocIterator reloc_iterator_;
     DISALLOW_COPY_AND_ASSIGN(CodeIterator);
   };
 
+  class BytecodeArrayIterator : public Iterator {
+   public:
+    BytecodeArrayIterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
+    ~BytecodeArrayIterator() override {}
+
+    BreakLocation GetBreakLocation() override;
+    bool Done() const override { return source_position_iterator_.done(); }
+    void Next() override;
+
+    int code_offset() override {
+      return source_position_iterator_.bytecode_offset();
+    }
+
+   private:
+    DebugBreakType GetDebugBreakType();
+
+    interpreter::SourcePositionTableIterator source_position_iterator_;
+    BreakLocatorType break_locator_type_;
+    int start_position_;
+    DISALLOW_COPY_AND_ASSIGN(BytecodeArrayIterator);
+  };
+
   static Iterator* GetIterator(Handle<DebugInfo> debug_info,
                                BreakLocatorType type = ALL_BREAK_LOCATIONS);
 
+ private:
   friend class Debug;
 
   static int BreakIndexFromCodeOffset(Handle<DebugInfo> debug_info, int offset);
 
   void SetDebugBreak();
   void ClearDebugBreak();
 
-  inline bool IsDebuggerStatement() const {
-    return type_ == DEBUGGER_STATEMENT;
-  }
-  inline bool IsDebugBreakSlot() const { return type_ >= DEBUG_BREAK_SLOT; }
-
   Handle<DebugInfo> debug_info_;
   int code_offset_;
   DebugBreakType type_;
   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.
@@ skipping 567 matching lines @@
                                   Handle<Code> code);
   static bool DebugBreakSlotIsPatched(Address pc);
   static void ClearDebugBreakSlot(Isolate* isolate, Address pc);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_H_