[interpreter] Reduce move operations for wide register support.

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"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 383 matching lines @@
           RegisterIsValid(to, OperandType::kReg16));
   } else if (FitsInReg8OperandUntranslated(to)) {
     CHECK(RegisterIsValid(from, OperandType::kReg16) &&
           RegisterIsValid(to, OperandType::kReg8));
   } else {
     UNIMPLEMENTED();
   }
   Output(Bytecode::kMovWide, from.ToRawOperand(), to.ToRawOperand());
 }
 
-bool BytecodeArrayBuilder::RegisterOperandIsMovable(Bytecode bytecode,
-                                                    int operand_index) {
-  // By design, we only support moving individual registers. There
-  // should be wide variants of such bytecodes instead to avoid the
-  // need for a large translation window.
-  OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
-  if (operand_type != OperandType::kReg8 &&
-      operand_type != OperandType::kReg16) {
-    return false;
-  } else if (operand_index + 1 == Bytecodes::NumberOfOperands(bytecode)) {
-    return true;
-  } else {
-    OperandType next_operand_type =
-        Bytecodes::GetOperandType(bytecode, operand_index + 1);
-    return (next_operand_type != OperandType::kRegCount8 &&
-            next_operand_type != OperandType::kRegCount16);
-  }
-}
-
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal(
     const Handle<String> name, int feedback_slot, LanguageMode language_mode,
     TypeofMode typeof_mode) {
   // TODO(rmcilroy): Potentially store language and typeof information in an
   // operand rather than having extra bytecodes.
   Bytecode bytecode = BytecodeForLoadGlobal(language_mode, typeof_mode);
   size_t name_index = GetConstantPoolEntry(name);
   if (FitsInIdx8Operand(name_index) && FitsInIdx8Operand(feedback_slot)) {
     Output(bytecode, static_cast<uint8_t>(name_index),
            static_cast<uint8_t>(feedback_slot));
@@ skipping 973 matching lines @@
       return static_cast<uint16_t>(operand_value) == operand_value;
     case OperandType::kImm8:
     case OperandType::kIdx8:
       return static_cast<uint8_t>(operand_value) == operand_value;
     case OperandType::kMaybeReg8:
       if (operand_value == 0) {
         return true;
       }
     // Fall-through to kReg8 case.
     case OperandType::kReg8:
+    case OperandType::kRegOut8:
       return RegisterIsValid(Register::FromRawOperand(operand_value),
                              operand_type);
+    case OperandType::kRegOutPair8:
+    case OperandType::kRegOutPair16:
     case OperandType::kRegPair8:
     case OperandType::kRegPair16: {
       Register reg0 = Register::FromRawOperand(operand_value);
       Register reg1 = Register(reg0.index() + 1);
       return RegisterIsValid(reg0, operand_type) &&
              RegisterIsValid(reg1, operand_type);
     }
-    case OperandType::kRegTriple8:
-    case OperandType::kRegTriple16: {
+    case OperandType::kRegOutTriple8:
+    case OperandType::kRegOutTriple16: {
       Register reg0 = Register::FromRawOperand(operand_value);
       Register reg1 = Register(reg0.index() + 1);
       Register reg2 = Register(reg0.index() + 2);
       return RegisterIsValid(reg0, operand_type) &&
              RegisterIsValid(reg1, operand_type) &&
              RegisterIsValid(reg2, operand_type);
     }
     case OperandType::kMaybeReg16:
       if (operand_value == 0) {
         return true;
       }
     // Fall-through to kReg16 case.
-    case OperandType::kReg16: {
+    case OperandType::kReg16:
+    case OperandType::kRegOut16: {
       Register reg = Register::FromRawOperand(operand_value);
       return RegisterIsValid(reg, operand_type);
     }
   }
   UNREACHABLE();
   return false;
 }
 
 
 bool BytecodeArrayBuilder::RegisterIsValid(Register reg,
@@ skipping 378 matching lines @@
 }
 
 // static
 bool BytecodeArrayBuilder::FitsInReg16OperandUntranslated(Register value) {
   return value.is_short_operand();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8