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

src/interpreter/bytecodes.cc

 // 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.
 
 #include "src/interpreter/bytecodes.h"
 
 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>(Operand::kNone) == 0);
+
+static const Operand kBytecodeTable[][kMaxOperands] = {
+#define DECLARE_OPERAND(_, ...) \
+  { __VA_ARGS__ }               \

[rmcilroy, 2015/07/27 14:56:57]

Does C++ always zero-initialize entries in an array? i.e., does:
 { Operand::kImm8 }
turn into
 { 1, 0, 0 }
here implicitly, or are entries [1] and [2] undefined?

[oth, 2015/07/27 17:09:53]

Yes, C++ will initialize these to zero provided at least one value is given. For
readability the declarations could include kNone as the last operand type or use
templates to pad out the arguments to explicitly include 0's.

The current nit that grates here is counting the operands at runtime rather than
compile time. The current pattern is more readable, but would be better to
determine at compile time.

[rmcilroy, 2015/07/28 08:58:12]

OK sounds good.
I'm not too worried about this since it will only be run when building the
interpreter bytecode handlers (usually at snapshot generation time), but if you
are worried you could build a separate table of operand counts using a hacky
trick like: 
  #define NUM_VAR_ARGS(...)  (sizeof((uint8_t[]){__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
   }
   UNREACHABLE();
   return "";
 }
 
 
 // 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);
+  CHECK(bytecode <= Bytecode::kLast);

[rmcilroy, 2015/07/27 14:56:57]

DCHECK

[oth, 2015/07/27 16:59:00]

Done.

+  return bytecode;
+}
+
+
+// static
+const int Bytecodes::NumberOfOperands(Bytecode bytecode) {
+  CHECK(bytecode <= Bytecode::kLast);

[rmcilroy, 2015/07/27 14:56:57]

DCHECK

[oth, 2015/07/27 16:59:00]

Done.

+  int count;
+  uint8_t row = ToByte(bytecode);
+  for (count = 0; count < kMaxOperands; count++) {
+    if (kBytecodeTable[row][count] == Operand::kNone) {
+      break;
+    }
   }
-  UNREACHABLE();
-  return 0;
+  return count;
+}
+
+
+// static
+const Operand Bytecodes::GetOperand(Bytecode bytecode, int i) {
+  CHECK(bytecode <= Bytecode::kLast && i < NumberOfOperands(bytecode));

[rmcilroy, 2015/07/27 14:56:57]

DCHECK

[oth, 2015/07/27 16:59:00]

Done.

+  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) {
   return os << Bytecodes::ToString(bytecode);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8