[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 390 matching lines @@
   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) {

[rmcilroy, 2016/01/26 16:49:51]

Purposefully dropping kReg16 from here?

[oth, 2016/01/26 17:55:53]

Yes, moves to the translation window are not needed for 16-bit register operands
as they are directly addressable by the 16-bit operand.

+      operand_type != OperandType::kRegOut8) {
     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);
   }
 }
@@ skipping 984 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