[interpreter] Add support for scalable operands.

src/interpreter/bytecode-array-iterator.h

Index: src/interpreter/bytecode-array-iterator.h
diff --git a/src/interpreter/bytecode-array-iterator.h b/src/interpreter/bytecode-array-iterator.h
index 5379bbf0288d3140db0e8114b2f7080c924289f1..6c10938e8892dbca7035d1ce53af01c6d7b22030 100644
--- a/src/interpreter/bytecode-array-iterator.h
+++ b/src/interpreter/bytecode-array-iterator.h
@@ -23,20 +23,26 @@ class BytecodeArrayIterator {
   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
@@ -44,8 +50,12 @@ class BytecodeArrayIterator {
   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);
 };