[interpreter] Add OSR nesting level to bytecode header.

src/objects.h

 // Copyright 2015 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_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 
 #include "src/assert-scope.h"
@@ skipping 4497 matching lines @@
   inline int register_count() const;
 
   // Accessors for parameter count (including implicit 'this' receiver).
   inline int parameter_count() const;
   inline void set_parameter_count(int number_of_parameters);
 
   // Accessors for profiling count.
   inline int interrupt_budget() const;
   inline void set_interrupt_budget(int interrupt_budget);
 
+  // Accessors for OSR loop nesting level.
+  inline int osr_loop_nesting_level() const;
+  inline void set_osr_loop_nesting_level(int depth);
+
   // Accessors for the constant pool.
   DECL_ACCESSORS(constant_pool, FixedArray)
 
   // Accessors for handler table containing offsets of exception handlers.
   DECL_ACCESSORS(handler_table, FixedArray)
 
   // Accessors for source position table containing mappings between byte code
   // offset and source position.
   DECL_ACCESSORS(source_position_table, ByteArray)
 
@@ skipping 19 matching lines @@
   void CopyBytecodesTo(BytecodeArray* to);
 
   // Layout description.
   static const int kConstantPoolOffset = FixedArrayBase::kHeaderSize;
   static const int kHandlerTableOffset = kConstantPoolOffset + kPointerSize;
   static const int kSourcePositionTableOffset =
       kHandlerTableOffset + kPointerSize;
   static const int kFrameSizeOffset = kSourcePositionTableOffset + kPointerSize;
   static const int kParameterSizeOffset = kFrameSizeOffset + kIntSize;
   static const int kInterruptBudgetOffset = kParameterSizeOffset + kIntSize;
-  static const int kHeaderSize = kInterruptBudgetOffset + kIntSize;
+  static const int kOSRNestingLevelOffset = kInterruptBudgetOffset + kIntSize;
+  static const int kHeaderSize = kOSRNestingLevelOffset + kIntSize;

[rmcilroy, 2016/07/22 09:46:01]

The OSR nesting level is always less than a byte (<=6), and the interrupt budget
is set to 0x1800 by flags, so less than two bytes. Could we pack these to avoid
increasing the size of the bytecode array? 

[Michael Starzinger, 2016/07/25 10:24:42]

As discussed offline: Yes, the OSR nesting level is fully bounded by
kMaxNestingLevel (i.e. <= 6). But the interrupt budget is not necessarily
bounded by the initial value, because forward branches will end up increasing
the value temporarily. The budget computation would need to truncate it to the
correct size. The following is an example of how I can imagine the value running
out of bounds (i.e. 32 * 0x1800 + 1000 * n) ...

function f() {
  if (x == 0) {
    // very large block containing n bytes of bytecode.
  }
  f(x - 1)
}
f(1000);

[rmcilroy, 2016/07/25 11:14:47]

Yeah this is an issue I hadn't thought of.  We could also potentially merge it
with parameter_count (since we seem to have a limit of 2^16 arguments in V8) but
it might not be worthwhile. Could you add a TODO(rmcilroy) in case we decide we
want to trim the size of bytecode arrays.

[Michael Starzinger, 2016/07/25 11:21:28]

Done.

 
   // Maximal memory consumption for a single BytecodeArray.
   static const int kMaxSize = 512 * MB;
   // Maximal length of a single BytecodeArray.
   static const int kMaxLength = kMaxSize - kHeaderSize;
 
   class BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(BytecodeArray);
@@ skipping 6427 matching lines @@
     }
     return value;
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #endif  // V8_OBJECTS_H_