[interpreter] Add support for scalable operands.

test/cctest/interpreter/bytecode-expectations-printer.cc

 // Copyright 2016 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 "test/cctest/interpreter/bytecode-expectations-printer.h"
 
 #include <iostream>
 #include <vector>
 
 #include "include/libplatform/libplatform.h"
@@ skipping 78 matching lines @@
         stream << "\\\\";
         break;
       default:
         stream << c;
         break;
     }
   }
 }
 
 namespace {
-i::Runtime::FunctionId IndexToFunctionId(int index) {
+i::Runtime::FunctionId IndexToFunctionId(uint32_t index) {
   return static_cast<i::Runtime::FunctionId>(index);
 }
 }  // namespace
 
 void BytecodeExpectationsPrinter::PrintBytecodeOperand(
     std::ostream& stream, const BytecodeArrayIterator& bytecode_iter,
     const Bytecode& bytecode, int op_index, int parameter_count) const {
   OperandType op_type = Bytecodes::GetOperandType(bytecode, op_index);
-  OperandSize op_size = Bytecodes::GetOperandSize(bytecode, op_index);
+  OperandSize op_size = Bytecodes::GetOperandSize(
+      bytecode, op_index, bytecode_iter.current_operand_scale());
 
   const char* size_tag;
   switch (op_size) {
     case OperandSize::kByte:
       size_tag = "8";
       break;
     case OperandSize::kShort:
       size_tag = "16";
       break;
+    case OperandSize::kQuad:
+      size_tag = "32";
+      break;
     default:
       UNREACHABLE();
       return;
   }
 
   if (Bytecodes::IsRegisterOperandType(op_type)) {
     Register register_value = bytecode_iter.GetRegisterOperand(op_index);
     stream << 'R';
     if (op_size != OperandSize::kByte) stream << size_tag;
     if (register_value.is_new_target()) {
       stream << "(new_target)";
     } else if (register_value.is_current_context()) {
       stream << "(context)";
     } else if (register_value.is_function_closure()) {
       stream << "(closure)";
     } else if (register_value.is_parameter()) {
       int parameter_index = register_value.ToParameterIndex(parameter_count);
       if (parameter_index == 0) {
         stream << "(this)";
       } else {
         stream << "(arg" << (parameter_index - 1) << ')';
       }
     } else {
       stream << '(' << register_value.index() << ')';
     }
   } else {
     stream << 'U' << size_tag << '(';
 
-    if (op_index == 0 && Bytecodes::IsCallRuntime(bytecode)) {
-      DCHECK_EQ(op_type, OperandType::kIdx16);
-      int operand = bytecode_iter.GetIndexOperand(op_index);
+    if (Bytecodes::IsRuntimeIdOperandType(op_type)) {
+      uint32_t operand = bytecode_iter.GetRuntimeIdOperand(op_index);
       stream << "Runtime::k"
              << i::Runtime::FunctionForId(IndexToFunctionId(operand))->name;
     } else if (Bytecodes::IsImmediateOperandType(op_type)) {
-      // We need a cast, otherwise the result is printed as char.
-      stream << static_cast<int>(bytecode_iter.GetImmediateOperand(op_index));
+      stream << bytecode_iter.GetImmediateOperand(op_index);
     } else if (Bytecodes::IsRegisterCountOperandType(op_type)) {
       stream << bytecode_iter.GetRegisterCountOperand(op_index);
+    } else if (Bytecodes::IsFlagOperandType(op_type)) {
+      stream << bytecode_iter.GetFlagOperand(op_index);
     } else if (Bytecodes::IsIndexOperandType(op_type)) {
       stream << bytecode_iter.GetIndexOperand(op_index);
     } else {
       UNREACHABLE();
     }
 
     stream << ')';
   }
 }
 
 void BytecodeExpectationsPrinter::PrintBytecode(
     std::ostream& stream, const BytecodeArrayIterator& bytecode_iter,
     int parameter_count) const {
   Bytecode bytecode = bytecode_iter.current_bytecode();
 
+  switch (bytecode_iter.current_operand_scale()) {
+    case 1:
+      break;
+    case 2:
+      stream << "B(" << Bytecodes::ToString(Bytecode::kWide) << "), ";
+      break;
+    case 4:
+      stream << "B(" << Bytecodes::ToString(Bytecode::kExtraWide) << "), ";
+      break;
+    default:
+      UNREACHABLE();
+      break;
+  }
   stream << "B(" << Bytecodes::ToString(bytecode) << ')';
 
   int operands_count = Bytecodes::NumberOfOperands(bytecode);
   for (int op_index = 0; op_index < operands_count; ++op_index) {
     stream << ", ";
     PrintBytecodeOperand(stream, bytecode_iter, bytecode, op_index,
                          parameter_count);
   }
 }
 
@@ skipping 123 matching lines @@
 
   stream << "---\n";
   PrintCodeSnippet(stream, snippet);
   PrintBytecodeArray(stream, bytecode_array);
   stream << '\n';
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8