[Interpreter]: Add kRegList operand type for register list operands.

src/interpreter/bytecode-array-builder.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/bytecode-array-builder.h"
 
 #include "src/globals.h"
 #include "src/interpreter/bytecode-array-writer.h"
 #include "src/interpreter/bytecode-dead-code-optimizer.h"
 #include "src/interpreter/bytecode-label.h"
@@ skipping 839 matching lines @@
   if (Bytecodes::NumberOfOperands(bytecode) != operand_count) {
     return false;
   }
 
   uint32_t operands[] = {operand0, operand1, operand2, operand3};
   const OperandType* operand_types = Bytecodes::GetOperandTypes(bytecode);
   for (int i = 0; i < operand_count; ++i) {
     switch (operand_types[i]) {
       case OperandType::kNone:
         return false;
-      case OperandType::kRegCount: {
-        CHECK_NE(i, 0);
-        CHECK(operand_types[i - 1] == OperandType::kMaybeReg ||
-              operand_types[i - 1] == OperandType::kReg);
-        if (i > 0 && operands[i] > 0) {
-          Register start = Register::FromOperand(operands[i - 1]);
-          Register end(start.index() + static_cast<int>(operands[i]) - 1);
-          if (!RegisterIsValid(start) || !RegisterIsValid(end) || start > end) {
-            return false;
-          }
-        }
-        break;
-      }
       case OperandType::kFlag8:
       case OperandType::kIntrinsicId:
         if (Bytecodes::SizeForUnsignedOperand(operands[i]) >
             OperandSize::kByte) {
           return false;
         }
         break;
       case OperandType::kRuntimeId:
         if (Bytecodes::SizeForUnsignedOperand(operands[i]) >
             OperandSize::kShort) {
           return false;
         }
         break;
       case OperandType::kIdx:
         // TODO(leszeks): Possibly split this up into constant pool indices and
         // other indices, for checking.
         break;
       case OperandType::kUImm:
       case OperandType::kImm:
         break;
-      case OperandType::kMaybeReg:
-        if (Register::FromOperand(operands[i]) == Register(0)) {
-          break;
+      case OperandType::kRegList: {
+        CHECK_LT(i, operand_count - 1);
+        CHECK(operand_types[i + 1] == OperandType::kRegCount);
+        int reg_count = static_cast<int>(operands[i + 1]);
+        if (reg_count == 0) {
+          return Register::FromOperand(operands[i]) == Register(0);
+        } else {
+          Register start = Register::FromOperand(operands[i]);
+          Register end(start.index() + reg_count - 1);
+          if (!RegisterIsValid(start) || !RegisterIsValid(end) || start > end) {
+            return false;
+          }
         }
-      // Fall-through to kReg case.
+        i++;  // Skip past kRegCount operand.
+        break;
+      }
       case OperandType::kReg:
       case OperandType::kRegOut: {
         Register reg = Register::FromOperand(operands[i]);
         if (!RegisterIsValid(reg)) {
           return false;
         }
         break;
       }
       case OperandType::kRegOutPair:
       case OperandType::kRegPair: {
         Register reg0 = Register::FromOperand(operands[i]);
         Register reg1 = Register(reg0.index() + 1);
         if (!RegisterIsValid(reg0) || !RegisterIsValid(reg1)) {
           return false;
         }
         break;
       }
       case OperandType::kRegOutTriple: {
         Register reg0 = Register::FromOperand(operands[i]);
         Register reg1 = Register(reg0.index() + 1);
         Register reg2 = Register(reg0.index() + 2);
         if (!RegisterIsValid(reg0) || !RegisterIsValid(reg1) ||
             !RegisterIsValid(reg2)) {
           return false;
         }
         break;
       }
+      case OperandType::kRegCount:
+        UNREACHABLE();  // Dealt with in kRegList above.
     }
   }
 
   return true;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8