Wrap back edge table in an iterator.

src/full-codegen.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_H_
 
 #include "v8.h"
 
 #include "allocation.h"
+#include "assert-scope.h"
 #include "ast.h"
 #include "code-stubs.h"
 #include "codegen.h"
 #include "compiler.h"
 #include "data-flow.h"
+#include "globals.h"
+#include "objects.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class JumpPatchSite;
 
 // AST node visitor which can tell whether a given statement will be breakable
 // when the code is compiled by the full compiler in the debugger. This means
 // that there will be an IC (load/store/call) in the code generated for the
@@ skipping 80 matching lines @@
 #elif V8_TARGET_ARCH_X64
   static const int kCodeSizeMultiplier = 162;
 #elif V8_TARGET_ARCH_ARM
   static const int kCodeSizeMultiplier = 142;
 #elif V8_TARGET_ARCH_MIPS
   static const int kCodeSizeMultiplier = 142;
 #else
 #error Unsupported target architecture.
 #endif
 
-  static const int kBackEdgeEntrySize = 3 * kIntSize;
+  class BackEdgeTableIterator {
+   public:
+    explicit BackEdgeTableIterator(Code* unoptimized) {
+      ASSERT(unoptimized->kind() == Code::FUNCTION);
+      instruction_start_ = unoptimized->instruction_start();
+      cursor_ = instruction_start_ + unoptimized->back_edge_table_offset();
+      ASSERT(cursor_ < instruction_start_ + unoptimized->instruction_size());
+      table_length_ = Memory::uint32_at(cursor_);
+      cursor_ += kTableLengthSize;
+      end_ = cursor_ + table_length_ * kEntrySize;
+    }
+
+    bool Done() { return cursor_ >= end_; }
+
+    void Next() {
+      ASSERT(!Done());
+      cursor_ += kEntrySize;
+    }
+
+    BailoutId ast_id() {
+      ASSERT(!Done());
+      return BailoutId(static_cast<int>(
+          Memory::uint32_at(cursor_ + kAstIdOffset)));
+    }
+
+    uint32_t loop_depth() {
+      ASSERT(!Done());
+      return Memory::uint32_at(cursor_ + kLoopDepthOffset);
+    }
+
+    uint32_t pc_offset() {
+      ASSERT(!Done());
+      return Memory::uint32_at(cursor_ + kPcOffsetOffset);
+    }
+
+    Address pc() {
+      ASSERT(!Done());
+      return instruction_start_ + pc_offset();
+    }
+
+    uint32_t table_length() { return table_length_; }
+
+   private:
+    static const int kTableLengthSize = kIntSize;
+    static const int kAstIdOffset = 0 * kIntSize;
+    static const int kPcOffsetOffset = 1 * kIntSize;
+    static const int kLoopDepthOffset = 2 * kIntSize;
+    static const int kEntrySize = 3 * kIntSize;
+
+    Address cursor_;
+    Address end_;
+    Address instruction_start_;
+    uint32_t table_length_;
+    DisallowHeapAllocation no_gc_while_iterating_over_raw_addresses_;
+
+    DISALLOW_COPY_AND_ASSIGN(BackEdgeTableIterator);
+  };
+
 
  private:
   class Breakable;
   class Iteration;
 
   class TestContext;
 
   class NestedStatement BASE_EMBEDDED {
    public:
     explicit NestedStatement(FullCodeGenerator* codegen) : codegen_(codegen) {
@@ skipping 726 matching lines @@
   }
 
  private:
   Zone* zone_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_