[interpreter] Add support for scalable operands.

src/interpreter/interpreter-assembler.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_INTERPRETER_ASSEMBLER_H_
 #define V8_INTERPRETER_INTERPRETER_ASSEMBLER_H_
 
 #include "src/allocation.h"
 #include "src/base/smart-pointers.h"
 #include "src/builtins.h"
 #include "src/compiler/code-stub-assembler.h"
 #include "src/frames.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/runtime/runtime.h"
 
 namespace v8 {
 namespace internal {
 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);
   // Returns the Imm8 immediate for bytecode operand |operand_index| in the
   // current bytecode.
   compiler::Node* BytecodeOperandImm(int operand_index);
   // Returns the register index for bytecode operand |operand_index| in the
   // current bytecode.
   compiler::Node* BytecodeOperandReg(int operand_index);
 
@@ skipping 91 matching lines @@
   // Dispatch to the bytecode.
   void Dispatch();
 
   // Dispatch to bytecode handler.
   void DispatchToBytecodeHandler(compiler::Node* handler,
                                  compiler::Node* bytecode_offset);
   void DispatchToBytecodeHandler(compiler::Node* handler) {
     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);
 
  protected:
   static bool TargetSupportsUnalignedAccess();
 
  private:
   // Returns a raw pointer to start of the register file on the stack.
   compiler::Node* RegisterFileRawPointer();
   // Returns a tagged pointer to the current function's BytecodeArray object.
@@ skipping 15 matching lines @@
   // Runtime::kInterrupt if counter reaches zero.
   void UpdateInterruptBudget(compiler::Node* weight);
 
   // Returns the offset of register |index| relative to RegisterFilePointer().
   compiler::Node* RegisterFrameOffset(compiler::Node* index);
 
   compiler::Node* BytecodeOperand(int operand_index);
   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.
   compiler::Node* Advance(int delta);
   compiler::Node* Advance(compiler::Node* delta);
 
   // Starts next instruction dispatch at |new_bytecode_offset|.
   void DispatchTo(compiler::Node* new_bytecode_offset);
 
   // Abort operations for debug code.
   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_;
 
   bool disable_stack_check_across_call_;
   compiler::Node* stack_pointer_before_call_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpreterAssembler);
 };
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_INTERPRETER_ASSEMBLER_H_