Revert of Make some functions that are hit during renderer startup available for inlining

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/interpreter/bytecode-traits.h"
@@ skipping 37 matching lines @@
 };
 
 const OperandSize* const Bytecodes::kOperandSizes[][3] = {
 #define ENTRY(Name, ...)                                    \
   { BytecodeTraits<__VA_ARGS__>::kSingleScaleOperandSizes,  \
     BytecodeTraits<__VA_ARGS__>::kDoubleScaleOperandSizes,  \
     BytecodeTraits<__VA_ARGS__>::kQuadrupleScaleOperandSizes },
   BYTECODE_LIST(ENTRY)
 #undef ENTRY
 };
-
-const OperandSize Bytecodes::kOperandKindSizes[][3] = {
-#define ENTRY(Name, ...)                                \
-  { OperandScaler<OperandType::k##Name,                 \
-                 OperandScale::kSingle>::kOperandSize,  \
-    OperandScaler<OperandType::k##Name,                 \
-                 OperandScale::kDouble>::kOperandSize,  \
-    OperandScaler<OperandType::k##Name,                 \
-                 OperandScale::kQuadruple>::kOperandSize },
-    OPERAND_TYPE_LIST(ENTRY)
-#undef ENTRY
-};
 // clang-format on
 
 // static
 const char* Bytecodes::ToString(Bytecode bytecode) {
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
     return #Name;
     BYTECODE_LIST(CASE)
 #undef CASE
@@ skipping 200 matching lines @@
 #define CASE(Name, _)        \
   case OperandType::k##Name: \
     return OperandTraits<OperandType::k##Name>::TypeInfoTraits::kIsUnsigned;
     OPERAND_TYPE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
 }
 
 // static
+OperandSize Bytecodes::SizeOfOperand(OperandType operand_type,
+                                     OperandScale operand_scale) {
+  DCHECK_LE(operand_type, OperandType::kLast);
+  DCHECK_GE(operand_scale, OperandScale::kSingle);
+  DCHECK_LE(operand_scale, OperandScale::kLast);
+  STATIC_ASSERT(static_cast<int>(OperandScale::kQuadruple) == 4 &&
+                OperandScale::kLast == OperandScale::kQuadruple);
+  int scale_index = static_cast<int>(operand_scale) >> 1;
+  // clang-format off
+  static const OperandSize kOperandSizes[][3] = {
+#define ENTRY(Name, ...)                                \
+  { OperandScaler<OperandType::k##Name,                 \
+                 OperandScale::kSingle>::kOperandSize,  \
+    OperandScaler<OperandType::k##Name,                 \
+                 OperandScale::kDouble>::kOperandSize,  \
+    OperandScaler<OperandType::k##Name,                 \
+                 OperandScale::kQuadruple>::kOperandSize },
+    OPERAND_TYPE_LIST(ENTRY)
+#undef ENTRY
+  };
+  // clang-format on
+  return kOperandSizes[static_cast<size_t>(operand_type)][scale_index];
+}
+
+// static
 bool Bytecodes::BytecodeHasHandler(Bytecode bytecode,
                                    OperandScale operand_scale) {
   return operand_scale == OperandScale::kSingle ||
          Bytecodes::IsBytecodeWithScalableOperands(bytecode);
 }
 
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode) {
   return os << Bytecodes::ToString(bytecode);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8