[Interpreter] Add support for short (16 bit) operands.

test/cctest/interpreter/test-bytecode-generator.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/v8.h"
 
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 111 matching lines @@
     int bytecode_index = i++;
     Bytecode bytecode = iterator.current_bytecode();
     if (Bytecodes::ToByte(bytecode) != expected.bytecode[bytecode_index]) {
       std::ostringstream stream;
       stream << "Check failed: expected bytecode [" << bytecode_index
              << "] to be " << Bytecodes::ToString(static_cast<Bytecode>(
                                   expected.bytecode[bytecode_index]))
              << " but got " << Bytecodes::ToString(bytecode);
       FATAL(stream.str().c_str());
     }
-    for (int j = 0; j < Bytecodes::NumberOfOperands(bytecode); ++j, ++i) {
-      uint8_t raw_operand =
-          iterator.GetRawOperand(j, Bytecodes::GetOperandType(bytecode, j));
+    for (int j = 0; j < Bytecodes::NumberOfOperands(bytecode); ++j) {
+      OperandType operand_type = Bytecodes::GetOperandType(bytecode, j);
+      int operand_index = i;
+      i += static_cast<int>(Bytecodes::SizeOfOperand(operand_type));
+      uint32_t raw_operand = iterator.GetRawOperand(j, operand_type);
       if (has_unknown) {
         // Check actual bytecode array doesn't have the same byte as the
         // one we use to specify an unknown byte.
         CHECK_NE(raw_operand, _);
-        if (expected.bytecode[i] == _) {
+        if (expected.bytecode[operand_index] == _) {
           continue;
         }
       }
-      if (raw_operand != expected.bytecode[i]) {
+      uint32_t expected_operand;
+      switch (Bytecodes::SizeOfOperand(operand_type)) {
+        case OperandSize::kNone:
+          UNREACHABLE();
+        case OperandSize::kByte:
+          expected_operand =
+              static_cast<uint32_t>(expected.bytecode[operand_index]);
+          break;
+        case OperandSize::kShort:
+          expected_operand = Bytecodes::ShortOperandFromBytes(
+              &expected.bytecode[operand_index]);
+          break;
+      }
+      if (raw_operand != expected_operand) {
         std::ostringstream stream;
         stream << "Check failed: expected operand [" << j << "] for bytecode ["
                << bytecode_index << "] to be "
-               << static_cast<unsigned int>(expected.bytecode[i]) << " but got "
+               << static_cast<unsigned int>(expected_operand) << " but got "
                << static_cast<unsigned int>(raw_operand);
         FATAL(stream.str().c_str());
       }
     }
     iterator.Advance();
   }
 }
 
 
 TEST(PrimitiveReturnStatements) {
@@ skipping 513 matching lines @@
        {
           B(LdaGlobal), _,
           B(Return)
        },
       },
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, "f");
-    bytecode_array->Print();
     CheckBytecodeArrayEqual(snippets[i], bytecode_array, true);
   }
 }
 
 
 TEST(CallGlobal) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   ExpectedSnippet<const char*> snippets[] = {
@@ skipping 179 matching lines @@
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunction(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespance v8