[interpreter] Add support for scalable operands.

test/unittests/interpreter/bytecodes-unittest.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 <vector>
 
 #include "src/v8.h"
 
 #include "src/interpreter/bytecodes.h"
 #include "test/unittests/test-utils.h"
@@ skipping 65 matching lines @@
 
   for (int i = 0; i < parameter_count; i += 1) {
     Register r = Register::FromParameterIndex(i, parameter_count);
     uint32_t operand = r.ToWideOperand();
     CHECK_LT(operand, operand_count.size());
     operand_count[operand] += 1;
     CHECK_EQ(operand_count[operand], 1);
   }
 }
 
+TEST(OperandScaling, ScalableAndNonScalable) {
+  for (int scale = 1; scale < 8; scale *= 2) {
+    CHECK_EQ(Bytecodes::Size(Bytecode::kCallRuntime, scale), 1 + 2 + 2 * scale);
+    CHECK_EQ(Bytecodes::Size(Bytecode::kCreateObjectLiteral, scale),
+             1 + 2 * scale + 1);
+    CHECK_EQ(Bytecodes::Size(Bytecode::kTestIn, scale), 1 + scale);
+  }
+}
+
 TEST(Bytecodes, HasAnyRegisterOperands) {
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kAdd), 1);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kCall), 2);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kCallRuntime), 1);
-  CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kCallRuntimeWide), 1);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kCallRuntimeForPair),
            2);
-  CHECK_EQ(
-      Bytecodes::NumberOfRegisterOperands(Bytecode::kCallRuntimeForPairWide),
-      2);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kDeletePropertyStrict),
            1);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kForInPrepare), 1);
-  CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kForInPrepareWide), 1);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kInc), 0);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kJumpIfTrue), 0);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kNew), 2);
   CHECK_EQ(Bytecodes::NumberOfRegisterOperands(Bytecode::kToName), 0);
 }
 
 TEST(Bytecodes, RegisterOperandBitmaps) {
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kAdd), 1);
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kCallRuntimeForPair),
            10);
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kStar), 1);
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kMov), 3);
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kTestIn), 1);
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kForInPrepare), 1);
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kForInDone), 3);
   CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kForInNext), 7);
 }
 
 TEST(Bytecodes, RegisterOperands) {
-  CHECK(Bytecodes::IsRegisterOperandType(OperandType::kReg8));
-  CHECK(Bytecodes::IsRegisterInputOperandType(OperandType::kReg8));
-  CHECK(!Bytecodes::IsRegisterOutputOperandType(OperandType::kReg8));
-  CHECK(!Bytecodes::IsRegisterInputOperandType(OperandType::kRegOut8));
-  CHECK(Bytecodes::IsRegisterOutputOperandType(OperandType::kRegOut8));
+  CHECK(Bytecodes::IsRegisterOperandType(OperandType::kReg));
+  CHECK(Bytecodes::IsRegisterInputOperandType(OperandType::kReg));
+  CHECK(!Bytecodes::IsRegisterOutputOperandType(OperandType::kReg));
+  CHECK(!Bytecodes::IsRegisterInputOperandType(OperandType::kRegOut));
+  CHECK(Bytecodes::IsRegisterOutputOperandType(OperandType::kRegOut));
 
-#define IS_REGISTER_OPERAND_TYPE(Name, _) \
+#define IS_REGISTER_OPERAND_TYPE(Name, _, __) \
   CHECK(Bytecodes::IsRegisterOperandType(OperandType::k##Name));
   REGISTER_OPERAND_TYPE_LIST(IS_REGISTER_OPERAND_TYPE)
 #undef IS_REGISTER_OPERAND_TYPE
 
-#define IS_NOT_REGISTER_OPERAND_TYPE(Name, _) \
+#define IS_NOT_REGISTER_OPERAND_TYPE(Name, _, __) \
   CHECK(!Bytecodes::IsRegisterOperandType(OperandType::k##Name));
   NON_REGISTER_OPERAND_TYPE_LIST(IS_NOT_REGISTER_OPERAND_TYPE)
 #undef IS_NOT_REGISTER_OPERAND_TYPE
 
-#define IS_REGISTER_INPUT_OPERAND_TYPE(Name, _) \
+#define IS_REGISTER_INPUT_OPERAND_TYPE(Name, _, __) \
   CHECK(Bytecodes::IsRegisterInputOperandType(OperandType::k##Name));
   REGISTER_INPUT_OPERAND_TYPE_LIST(IS_REGISTER_INPUT_OPERAND_TYPE)
 #undef IS_REGISTER_INPUT_OPERAND_TYPE
 
-#define IS_NOT_REGISTER_INPUT_OPERAND_TYPE(Name, _) \
+#define IS_NOT_REGISTER_INPUT_OPERAND_TYPE(Name, _, __) \
   CHECK(!Bytecodes::IsRegisterInputOperandType(OperandType::k##Name));
   NON_REGISTER_OPERAND_TYPE_LIST(IS_NOT_REGISTER_INPUT_OPERAND_TYPE);
   REGISTER_OUTPUT_OPERAND_TYPE_LIST(IS_NOT_REGISTER_INPUT_OPERAND_TYPE)
 #undef IS_NOT_REGISTER_INPUT_OPERAND_TYPE
 
-#define IS_REGISTER_OUTPUT_OPERAND_TYPE(Name, _) \
+#define IS_REGISTER_OUTPUT_OPERAND_TYPE(Name, _, __) \
   CHECK(Bytecodes::IsRegisterOutputOperandType(OperandType::k##Name));
   REGISTER_OUTPUT_OPERAND_TYPE_LIST(IS_REGISTER_OUTPUT_OPERAND_TYPE)
 #undef IS_REGISTER_OUTPUT_OPERAND_TYPE
 
-#define IS_NOT_REGISTER_OUTPUT_OPERAND_TYPE(Name, _) \
+#define IS_NOT_REGISTER_OUTPUT_OPERAND_TYPE(Name, _, __) \
   CHECK(!Bytecodes::IsRegisterOutputOperandType(OperandType::k##Name));
   NON_REGISTER_OPERAND_TYPE_LIST(IS_NOT_REGISTER_OUTPUT_OPERAND_TYPE)
   REGISTER_INPUT_OPERAND_TYPE_LIST(IS_NOT_REGISTER_OUTPUT_OPERAND_TYPE)
 #undef IS_NOT_REGISTER_INPUT_OPERAND_TYPE
 }
 
-TEST(Bytecodes, DebugBreak) {
-  for (uint32_t i = 0; i < Bytecodes::ToByte(Bytecode::kLast); i++) {
-    Bytecode bytecode = Bytecodes::FromByte(i);
-    Bytecode debugbreak = Bytecodes::GetDebugBreak(bytecode);
-    if (!Bytecodes::IsDebugBreak(debugbreak)) {
-      PrintF("Bytecode %s has no matching debug break with length %d\n",
-             Bytecodes::ToString(bytecode), Bytecodes::Size(bytecode));
-      CHECK(false);
-    }
+TEST(Bytecodes, DebugBreakExistForEachBytecode) {
+  for (int operand_scale = 1; operand_scale < 8; operand_scale *= 2) {
+#define CHECK_DEBUG_BREAK_SIZE(Name, ...)                           \
+  {                                                                 \
+    Bytecode debug_bytecode =                                       \
+        Bytecodes::GetDebugBreak(Bytecode::k##Name, operand_scale); \
+    CHECK_EQ(Bytecodes::Size(Bytecode::k##Name, operand_scale),     \
+             Bytecodes::Size(debug_bytecode, operand_scale));       \
+  }
+    BYTECODE_LIST(CHECK_DEBUG_BREAK_SIZE)
+#undef CHECK_DEBUG_BREAK_SIZE
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8