[interpreter] Add support for scalable operands.

src/interpreter/interpreter-assembler.h

Index: src/interpreter/interpreter-assembler.h
diff --git a/src/interpreter/interpreter-assembler.h b/src/interpreter/interpreter-assembler.h
index 2a1672a9114f63e7e86bb6ac6f5bfbeadfd1fdca..052955a407a6bf1c9a8403897aa4b2f11703edc0 100644
--- a/src/interpreter/interpreter-assembler.h
+++ b/src/interpreter/interpreter-assembler.h
@@ -19,12 +19,18 @@ namespace interpreter {
 
 class InterpreterAssembler : public compiler::CodeStubAssembler {
  public:
-  InterpreterAssembler(Isolate* isolate, Zone* zone, Bytecode bytecode);
+  InterpreterAssembler(Isolate* isolate, Zone* zone, Bytecode bytecode,
+                       int operand_scale);
+  // Constructor for illegal bytecode codepoints.

[rmcilroy, 2016/03/10 16:45:37]

Could we just add a kIllegal bytecode to avoid having to special case the
constructor? That would mean we could return it on unreachable codepaths instead
of static_cast<Bytecode>(-1).

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

Done.

+  InterpreterAssembler(Isolate* isolate, Zone* zone);
   virtual ~InterpreterAssembler();
 
   // Returns the count immediate for bytecode operand |operand_index| in the
   // current bytecode.
   compiler::Node* BytecodeOperandCount(int operand_index);
+  // Returns the 8-bit flag for bytecode operand |operand_index| in the
+  // current bytecode.
+  compiler::Node* BytecodeOperandFlag(int operand_index);
   // Returns the index immediate for bytecode operand |operand_index| in the
   // current bytecode.
   compiler::Node* BytecodeOperandIdx(int operand_index);
@@ -136,6 +142,9 @@ class InterpreterAssembler : public compiler::CodeStubAssembler {
     DispatchToBytecodeHandler(handler, BytecodeOffset());
   }
 
+  // Dispatch bytecode as wide operand variant.
+  void RedispatchWide();

[rmcilroy, 2016/03/10 16:45:37]

Could we do the logic for this in interpreter.cc and just reuse
DispatchToBytecodeHandler instead?

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

No problem moving this, but it seems very similar to plain old Dispatch(). The
implementation uses DispatchToBytecodeHandler and is common to both Wide and
ExtraWide bytecodes.

[oth, 2016/03/15 09:58:28]

Looking into this, more of the interpreter assemblers internals (bytecode
offset, bytecode array, dispatch table) need to be exposed to support this. This
information seems to have the right accessibility as-is.

[rmcilroy, 2016/03/16 11:55:54]

Ok that's fine. Please rename as DispatchWide though since you aren't
redispatching the current bytecode, just ensuring that the next bytecode is
treated as wide.

[oth, 2016/03/17 13:48:38]

Done.

+
   // Abort with the given bailout reason.
   void Abort(BailoutReason bailout_reason);
 
@@ -171,6 +180,8 @@ class InterpreterAssembler : public compiler::CodeStubAssembler {
   compiler::Node* BytecodeOperandSignExtended(int operand_index);
   compiler::Node* BytecodeOperandShort(int operand_index);
   compiler::Node* BytecodeOperandShortSignExtended(int operand_index);
+  compiler::Node* BytecodeOperandQuad(int operand_index);
+  compiler::Node* BytecodeOperandQuadSignExtended(int operand_index);
 
   // Returns BytecodeOffset() advanced by delta bytecodes. Note: this does not
   // update BytecodeOffset() itself.
@@ -184,7 +195,10 @@ class InterpreterAssembler : public compiler::CodeStubAssembler {
   void AbortIfWordNotEqual(compiler::Node* lhs, compiler::Node* rhs,
                            BailoutReason bailout_reason);
 
+  int operand_scale() const { return operand_scale_; }
+
   Bytecode bytecode_;
+  int operand_scale_;
   CodeStubAssembler::Variable accumulator_;
   CodeStubAssembler::Variable context_;
   CodeStubAssembler::Variable bytecode_array_;