[interpreter] Streamline bytecode array writing.

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"
 
 #include <iomanip>
 
 #include "src/base/bits.h"
 #include "src/frames.h"
 #include "src/interpreter/bytecode-traits.h"
 #include "src/interpreter/interpreter.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
+STATIC_CONST_MEMBER_DEFINITION const int Bytecodes::kMaxOperands;
 
 // static
 const char* Bytecodes::ToString(Bytecode bytecode) {
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
     return #Name;
     BYTECODE_LIST(CASE)
 #undef CASE
   }
@@ skipping 307 matching lines @@
 #undef CASE
   }
   UNREACHABLE();
   return nullptr;
 }
 
 // static
 OperandSize Bytecodes::GetOperandSize(Bytecode bytecode, int i,
                                       OperandScale operand_scale) {
   DCHECK_LT(i, NumberOfOperands(bytecode));
-  return GetOperandSizes(bytecode, operand_scale)[i];
+  OperandType operand_type = GetOperandType(bytecode, i);
+  return SizeOfOperand(operand_type, operand_scale);
 }
 
 // static
-const OperandSize* Bytecodes::GetOperandSizes(Bytecode bytecode,
-                                              OperandScale operand_scale) {
-  DCHECK(bytecode <= Bytecode::kLast);
-  switch (bytecode) {
-#define CASE(Name, ...)   \
-  case Bytecode::k##Name: \
-    return BytecodeTraits<__VA_ARGS__>::GetOperandSizes(operand_scale);
-    BYTECODE_LIST(CASE)
-#undef CASE
-  }
-  UNREACHABLE();
-  return nullptr;
-}
-
-// static
-int Bytecodes::GetRegisterOperandBitmap(Bytecode bytecode) {
-  DCHECK(bytecode <= Bytecode::kLast);
-  switch (bytecode) {
-#define CASE(Name, ...)                              \
-  case Bytecode::k##Name:                            \
-    typedef BytecodeTraits<__VA_ARGS__> Name##Trait; \
-    return Name##Trait::kRegisterOperandBitmap;
-    BYTECODE_LIST(CASE)
-#undef CASE
-  }
-  UNREACHABLE();
-  return false;
-}
-
-// static
 int Bytecodes::GetOperandOffset(Bytecode bytecode, int i,
                                 OperandScale operand_scale) {
   DCHECK_LT(i, Bytecodes::NumberOfOperands(bytecode));
   // TODO(oth): restore this to a statically determined constant.
   int offset = 1;
   for (int operand_index = 0; operand_index < i; ++operand_index) {
     OperandSize operand_size =
         GetOperandSize(bytecode, operand_index, operand_scale);
     offset += static_cast<int>(operand_size);
   }
@@ skipping 207 matching lines @@
     case OperandType::kMaybeReg:
     case OperandType::kReg:
     case OperandType::kRegOut:
       return 1;
     case OperandType::kRegPair:
     case OperandType::kRegOutPair:
       return 2;
     case OperandType::kRegOutTriple:
       return 3;
     default:
-      UNREACHABLE();
+      return 0;
   }
   return 0;
 }
 
 // static
 bool Bytecodes::IsUnsignedOperandType(OperandType operand_type) {
   switch (operand_type) {
 #define CASE(Name, _)        \
   case OperandType::k##Name: \
     return OperandTraits<OperandType::k##Name>::TypeInfoTraits::kIsUnsigned;
@@ skipping 323 matching lines @@
   } else {
     std::ostringstream s;
     s << "r" << index();
     return s.str();
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8