[interpreter] Add support for scalable operands.

src/interpreter/bytecode-array-iterator.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_INTERPRETER_BYTECODE_ARRAY_ITERATOR_H_
 #define V8_INTERPRETER_BYTECODE_ARRAY_ITERATOR_H_
 
 #include "src/handles.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/objects.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 class BytecodeArrayIterator {
  public:
   explicit BytecodeArrayIterator(Handle<BytecodeArray> bytecode_array);
 
   void Advance();
   bool done() const;
   Bytecode current_bytecode() const;
   int current_bytecode_size() const;
   void set_current_offset(int offset) { bytecode_offset_ = offset; }

[rmcilroy, 2016/03/11 11:35:20]

Just though about this - we need to do something for the set_current_offset
call, currently it doesn't update the scale appropriately. Currently it is only
used by Runtime_TraceBytecode*, so maybe we just get rid of it and have
Runtime_TraceBytecode advance until it reaches the correct location. WDYT?

[oth, 2016/03/11 16:26:13]

Good catch.

The latest rev does multiple Advance()'s if the previous bytecode could be
interpreted as a widening prefix, otherwise just sets the iterator position
accordingly.

It's a bit ugly at the moment as we filter out the tracing for just the widening
bytecode. We might do this earlier in the call stack as the changes progress.

   int current_offset() const { return bytecode_offset_; }
+  int current_operand_scale() const { return operand_scale_; }
+  int current_prefix_offset() const { return prefix_offset_; }
   const Handle<BytecodeArray>& bytecode_array() const {
     return bytecode_array_;
   }
 
-  int8_t GetImmediateOperand(int operand_index) const;
-  int GetIndexOperand(int operand_index) const;
-  int GetRegisterCountOperand(int operand_index) const;
+  uint32_t GetFlagOperand(int operand_index) const;
+  int32_t GetImmediateOperand(int operand_index) const;
+  uint32_t GetIndexOperand(int operand_index) const;
+  uint32_t GetRegisterCountOperand(int operand_index) const;
   Register GetRegisterOperand(int operand_index) const;
   int GetRegisterOperandRange(int operand_index) const;
+  uint32_t GetRuntimeIdOperand(int operand_index) const;
   Handle<Object> GetConstantForIndexOperand(int operand_index) const;
 
   // Get the raw byte for the given operand. Note: you should prefer using the
   // typed versions above which cast the return to an appropriate type.
   uint32_t GetRawOperand(int operand_index, OperandType operand_type) const;
+  int32_t GetRawOperandSigned(int operand_index,
+                              OperandType operand_type) const;
 
   // Returns the absolute offset of the branch target at the current
   // bytecode. It is an error to call this method if the bytecode is
   // not for a jump or conditional jump.
   int GetJumpTargetOffset() const;
 
  private:
+  void update_operand_scale();
+
   Handle<BytecodeArray> bytecode_array_;
   int bytecode_offset_;
+  int operand_scale_;
+  int prefix_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(BytecodeArrayIterator);
 };
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODE_GRAPH_ITERATOR_H_