[Interpreter] Add more bytecode definitions and add operand types.

BUG=v8:4280
LOG=N

Review URL: https://codereview.chromium.org/1257543003

Cr-Commit-Position: refs/heads/master@{#29934}

src/compiler/interpreter-assembler.cc

@@ -95,8 +95,8 @@ Node* InterpreterAssembler::RegisterFrameOffset(Node* index) {
 }
 
 
-Node* InterpreterAssembler::BytecodeArg(int delta) {
-  DCHECK_LT(delta, interpreter::Bytecodes::NumberOfArguments(bytecode_));
+Node* InterpreterAssembler::BytecodeOperand(int delta) {
+  DCHECK_LT(delta, interpreter::Bytecodes::NumberOfOperands(bytecode_));
   return raw_assembler_->Load(
       kMachUint8, BytecodeArrayPointer(),
       raw_assembler_->IntPtrAdd(BytecodeOffset(), Int32Constant(1 + delta)));

src/compiler/interpreter-assembler.h

@@ -43,8 +43,8 @@ class InterpreterAssembler {
   Node* NumberConstant(double value);
   Node* HeapConstant(Unique<HeapObject> object);
 
-  // Returns the bytecode argument |index| for the current bytecode.
-  Node* BytecodeArg(int index);
+  // Returns the bytecode operand |index| for the current bytecode.
+  Node* BytecodeOperand(int index);
 
   // Loads from and stores to the interpreter register file.
   Node* LoadRegister(int index);

src/interpreter/bytecodes.cc

@@ -8,12 +8,27 @@ namespace v8 {
 namespace internal {
 namespace interpreter {
 
+// Maximum number of operands a bytecode may have.
+static const int kMaxOperands = 3;
+
+// kBytecodeTable relies on kNone being the same as zero to detect length.
+STATIC_ASSERT(static_cast<int>(OperandType::kNone) == 0);
+
+static const OperandType kBytecodeTable[][kMaxOperands] = {
+#define DECLARE_OPERAND(_, ...) \
+  { __VA_ARGS__ }               \
+  ,
+    BYTECODE_LIST(DECLARE_OPERAND)
+#undef DECLARE_OPERAND
+};
+
+
 // static
 const char* Bytecodes::ToString(Bytecode bytecode) {
   switch (bytecode) {
-#define CASE(Name, _)       \
-    case Bytecode::k##Name: \
-      return #Name;
+#define CASE(Name, ...)   \
+  case Bytecode::k##Name: \
+    return #Name;
     BYTECODE_LIST(CASE)
 #undef CASE
   }
@@ -23,29 +38,52 @@ const char* Bytecodes::ToString(Bytecode bytecode) {
 
 
 // static
-const int Bytecodes::NumberOfArguments(Bytecode bytecode) {
-  switch (bytecode) {
-#define CASE(Name, arg_count)   \
-    case Bytecode::k##Name:     \
-      return arg_count;
-    BYTECODE_LIST(CASE)
-#undef CASE
+uint8_t Bytecodes::ToByte(Bytecode bytecode) {
+  return static_cast<uint8_t>(bytecode);
+}
+
+
+// static
+Bytecode Bytecodes::FromByte(uint8_t value) {
+  Bytecode bytecode = static_cast<Bytecode>(value);
+  DCHECK(bytecode <= Bytecode::kLast);
+  return bytecode;
+}
+
+
+// static
+const int Bytecodes::NumberOfOperands(Bytecode bytecode) {
+  DCHECK(bytecode <= Bytecode::kLast);
+  int count;
+  uint8_t row = ToByte(bytecode);
+  for (count = 0; count < kMaxOperands; count++) {
+    if (kBytecodeTable[row][count] == OperandType::kNone) {
+      break;
+    }
   }
-  UNREACHABLE();
-  return 0;
+  return count;
+}
+
+
+// static
+const OperandType Bytecodes::GetOperandType(Bytecode bytecode, int i) {
+  DCHECK(bytecode <= Bytecode::kLast && i < NumberOfOperands(bytecode));
+  return kBytecodeTable[ToByte(bytecode)][i];
 }
 
 
 // static
 const int Bytecodes::Size(Bytecode bytecode) {
-  return NumberOfArguments(bytecode) + 1;
+  return 1 + NumberOfOperands(bytecode);
 }
 
 
-#define CHECK_SIZE(Name, arg_count) \
-  STATIC_ASSERT(arg_count <= Bytecodes::kMaximumNumberOfArguments);
-  BYTECODE_LIST(CHECK_SIZE)
-#undef CHECK_SIZE
+// static
+const int Bytecodes::MaximumNumberOfOperands() { return kMaxOperands; }
+
+
+// static
+const int Bytecodes::MaximumSize() { return 1 + kMaxOperands; }
 
 
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode) {

src/interpreter/bytecodes.h

@@ -15,38 +15,70 @@ namespace v8 {
 namespace internal {
 namespace interpreter {
 
+// The list of operand types used by bytecodes.
+#define OPERAND_TYPE_LIST(V) \
+  V(None)                    \
+  V(Imm8)                    \
+  V(Reg)
+
 // The list of bytecodes which are interpreted by the interpreter.
-#define BYTECODE_LIST(V) \
-  V(LoadLiteral0, 1)     \
-  V(Return, 0)
+#define BYTECODE_LIST(V)                             \
+  V(LoadLiteral0, OperandType::kReg)                 \
+  V(LoadSmi8, OperandType::kReg, OperandType::kImm8) \
+  V(Return, OperandType::kNone)
+
+
+// Enumeration of operand types used by bytecodes.
+enum class OperandType : uint8_t {
+#define DECLARE_OPERAND_TYPE(Name) k##Name,
+  OPERAND_TYPE_LIST(DECLARE_OPERAND_TYPE)
+#undef DECLARE_OPERAND_TYPE
+#define COUNT_OPERAND_TYPES(x) +1
+  // The COUNT_OPERAND macro will turn this into kLast = -1 +1 +1... which will
+  // evaluate to the same value as the last operand.
+  kLast = -1 OPERAND_TYPE_LIST(COUNT_OPERAND_TYPES)
+#undef COUNT_OPERAND_TYPES
+};
+
 
+// Enumeration of interpreter bytecodes.
 enum class Bytecode : uint8_t {
-#define DECLARE_BYTECODE(Name, _) k##Name,
+#define DECLARE_BYTECODE(Name, ...) k##Name,
   BYTECODE_LIST(DECLARE_BYTECODE)
 #undef DECLARE_BYTECODE
-#define COUNT_BYTECODE(x, _) +1
+#define COUNT_BYTECODE(x, ...) +1
   // The COUNT_BYTECODE macro will turn this into kLast = -1 +1 +1... which will
   // evaluate to the same value as the last real bytecode.
   kLast = -1 BYTECODE_LIST(COUNT_BYTECODE)
 #undef COUNT_BYTECODE
 };
 
+
 class Bytecodes {
  public:
   // Returns string representation of |bytecode|.
   static const char* ToString(Bytecode bytecode);
 
-  // Returns the number of arguments expected by |bytecode|.
-  static const int NumberOfArguments(Bytecode bytecode);
+  // Returns byte value of bytecode.
+  static uint8_t ToByte(Bytecode bytecode);
+
+  // Returns bytecode for |value|.
+  static Bytecode FromByte(uint8_t value);
+
+  // Returns the number of operands expected by |bytecode|.
+  static const int NumberOfOperands(Bytecode bytecode);
+
+  // Return the i-th operand of |bytecode|.
+  static const OperandType GetOperandType(Bytecode bytecode, int i);
 
   // Returns the size of the bytecode including its arguments.
   static const int Size(Bytecode bytecode);
 
-  // The maximum number of arguments across all bytecodes.
-  static const int kMaximumNumberOfArguments = 1;
+  // The maximum number of operands across all bytecodes.
+  static const int MaximumNumberOfOperands();
 
   // Maximum size of a bytecode and its arguments.
-  static const int kMaximumSize = 1 + kMaximumNumberOfArguments;
+  static const int MaximumSize();
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Bytecodes);

src/interpreter/interpreter.cc

@@ -34,29 +34,40 @@ void Interpreter::Initialize(bool create_heap_objects) {
         handler_table->address()));
     isolate_->heap()->public_set_interpreter_table(*handler_table);
 
-#define GENERATE_CODE(Name, _)                                         \
-    {                                                                  \
-      compiler::InterpreterAssembler assembler(isolate_, &zone,        \
-                                               Bytecode::k##Name);     \
-      Do##Name(&assembler);                                            \
-      Handle<Code> code = assembler.GenerateCode();                    \
-      handler_table->set(static_cast<int>(Bytecode::k##Name), *code);  \
-    }
+#define GENERATE_CODE(Name, ...)                                    \
+  {                                                                 \
+    compiler::InterpreterAssembler assembler(isolate_, &zone,       \
+                                             Bytecode::k##Name);    \
+    Do##Name(&assembler);                                           \
+    Handle<Code> code = assembler.GenerateCode();                   \
+    handler_table->set(static_cast<int>(Bytecode::k##Name), *code); \
+  }
     BYTECODE_LIST(GENERATE_CODE)
 #undef GENERATE_CODE
   }
 }
 
 
-// Load literal '0' into the register index specified by the bytecode's
-// argument.
+// LoadLiteral0 <dst>
+//
+// Load literal '0' into the destination register.
 void Interpreter::DoLoadLiteral0(compiler::InterpreterAssembler* assembler) {
-  Node* register_index = __ BytecodeArg(0);
+  Node* register_index = __ BytecodeOperand(0);
   __ StoreRegister(__ NumberConstant(0), register_index);
   __ Dispatch();
 }
 
 
+// LoadSmi8 <dst>, <imm8>
+//
+// Load an 8-bit integer literal into destination register as a Smi.
+void Interpreter::DoLoadSmi8(compiler::InterpreterAssembler* assembler) {
+  // TODO(rmcilroy) Convert an 8-bit integer to a Smi.
+}
+
+
+// Return
+//
 // Return the value in register 0.
 void Interpreter::DoReturn(compiler::InterpreterAssembler* assembler) {
   __ Return();

src/interpreter/interpreter.h

@@ -32,7 +32,7 @@ class Interpreter {
 
  private:
 // Bytecode handler generator functions.
-#define DECLARE_BYTECODE_HANDLER_GENERATOR(Name, _) \
+#define DECLARE_BYTECODE_HANDLER_GENERATOR(Name, ...) \
   void Do##Name(compiler::InterpreterAssembler* assembler);
   BYTECODE_LIST(DECLARE_BYTECODE_HANDLER_GENERATOR)
 #undef DECLARE_BYTECODE_HANDLER_GENERATOR

src/objects.cc

@@ -11611,18 +11611,18 @@ void Code::Disassemble(const char* name, std::ostream& os) {  // NOLINT
 void BytecodeArray::Disassemble(std::ostream& os) {
   os << "Frame size " << frame_size() << "\n";
   Vector<char> buf = Vector<char>::New(50);
-  int bytecode_size = 0;
-  for (int i = 0; i < this->length(); i += bytecode_size) {
-    interpreter::Bytecode bytecode = static_cast<interpreter::Bytecode>(get(i));
-    bytecode_size = interpreter::Bytecodes::Size(bytecode);
+  int bytes = 0;
+  for (int i = 0; i < this->length(); i += bytes) {
+    interpreter::Bytecode bytecode = interpreter::Bytecodes::FromByte(get(i));
+    bytes = interpreter::Bytecodes::Size(bytecode);
 
     SNPrintF(buf, "%p : ", GetFirstBytecodeAddress() + i);
     os << buf.start();
-    for (int j = 0; j < bytecode_size; j++) {
+    for (int j = 0; j < bytes; j++) {
       SNPrintF(buf, "%02x ", get(i + j));
       os << buf.start();
     }
-    for (int j = bytecode_size; j < interpreter::Bytecodes::kMaximumSize; j++) {
+    for (int j = bytes; j < interpreter::Bytecodes::MaximumSize(); j++) {
       os << "   ";
     }
     os << bytecode << "\n";

test/unittests/compiler/interpreter-assembler-unittest.cc

@@ -15,7 +15,7 @@ namespace internal {
 namespace compiler {
 
 const interpreter::Bytecode kBytecodes[] = {
-#define DEFINE_BYTECODE(Name, _) interpreter::Bytecode::k##Name,
+#define DEFINE_BYTECODE(Name, ...) interpreter::Bytecode::k##Name,
     BYTECODE_LIST(DEFINE_BYTECODE)
 #undef DEFINE_BYTECODE
 };
@@ -127,12 +127,12 @@ TARGET_TEST_F(InterpreterAssemblerTest, Return) {
 }
 
 
-TARGET_TEST_F(InterpreterAssemblerTest, BytecodeArg) {
+TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperand) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
-    int number_of_args = interpreter::Bytecodes::NumberOfArguments(bytecode);
-    for (int i = 0; i < number_of_args; i++) {
-      Node* load_arg_node = m.BytecodeArg(i);
+    int number_of_operands = interpreter::Bytecodes::NumberOfOperands(bytecode);
+    for (int i = 0; i < number_of_operands; i++) {
+      Node* load_arg_node = m.BytecodeOperand(i);
       EXPECT_THAT(
           load_arg_node,
           m.IsLoad(