[interpreter] Reduce move operations for wide register support.

test/unittests/interpreter/register-translator-unittest.cc

 // Copyright 2014 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 <stack>
 
 #include "src/v8.h"
 
 #include "src/interpreter/register-translator.h"
 #include "src/isolate.h"
@@ skipping 34 matching lines @@
 
  private:
   void MoveRegisterUntranslated(Register from, Register to) override {
     moves_.push(std::make_pair(from, to));
     move_count_++;
   }
 
   bool RegisterOperandIsMovable(Bytecode bytecode, int operand_index) override {
     OperandType operand_type =
         Bytecodes::GetOperandType(bytecode, operand_index);
+
+    EXPECT_TRUE(Bytecodes::IsRegisterOperandType(operand_type));
     if (operand_type == OperandType::kReg8 ||
-        operand_type == OperandType::kReg16) {
+        operand_type == OperandType::kRegOut8) {
       if (operand_index == Bytecodes::NumberOfOperands(bytecode) - 1) {
         return true;
       }
       OperandType next_operand_type =
           Bytecodes::GetOperandType(bytecode, operand_index + 1);
       return (next_operand_type != OperandType::kRegCount8 &&
               next_operand_type != OperandType::kRegCount16);
     } else {
       return false;
     }
   }
 
   RegisterTranslator translator_;
   std::stack<std::pair<Register, Register>> moves_;
   int move_count_;
   int window_start_;
   int window_width_;
 };
 
 const char* const RegisterTranslatorTest::kBadOperandRegex =
-    ".*OperandType::kReg8 && mover\\(\\)->RegisterOperandIsMovable.*";
+    ".*OperandType::kReg8 \\|\\| .*OperandType::kRegOut8\\) && "
+    "mover\\(\\)->RegisterOperandIsMovable.*";
 
 TEST_F(RegisterTranslatorTest, TestFrameSizeAdjustmentsForTranslationWindow) {
   EXPECT_EQ(0, RegisterTranslator::RegisterCountAdjustment(0, 0));
   EXPECT_EQ(0, RegisterTranslator::RegisterCountAdjustment(10, 10));
   EXPECT_EQ(window_width(),
             RegisterTranslator::RegisterCountAdjustment(173, 0));
   EXPECT_EQ(window_width(),
             RegisterTranslator::RegisterCountAdjustment(173, 137));
   EXPECT_EQ(window_width(),
             RegisterTranslator::RegisterCountAdjustment(173, 137));
@@ skipping 62 matching lines @@
 TEST_F(RegisterTranslatorTest, NoTranslationRequired) {
   Register window_reg(window_start());
   Register local_reg(57);
   uint32_t operands[] = {local_reg.ToRawOperand()};
   translator()->TranslateInputRegisters(Bytecode::kLdar, operands, 1);
   translator()->TranslateOutputRegisters();
   EXPECT_EQ(0, move_count());
 
   Register param_reg = Register::FromParameterIndex(129, 130);
   operands[0] = param_reg.ToRawOperand();
-  translator()->TranslateInputRegisters(Bytecode::kLdar, operands, 1);
+  translator()->TranslateInputRegisters(Bytecode::kAdd, operands, 1);
   translator()->TranslateOutputRegisters();
   EXPECT_EQ(0, move_count());
 }
 
 TEST_F(RegisterTranslatorTest, TranslationRequired) {
   Register window_reg(window_start());
   Register local_reg(137);
   Register local_reg_translated(local_reg.index() + window_width());
 
   uint32_t operands[] = {local_reg.ToRawOperand()};
   translator()->TranslateInputRegisters(Bytecode::kLdar, operands, 1);
   EXPECT_EQ(1, move_count());
   EXPECT_TRUE(PopMoveAndMatch(local_reg_translated, window_reg));
   translator()->TranslateOutputRegisters();
+  EXPECT_EQ(1, move_count());
+  EXPECT_FALSE(PopMoveAndMatch(window_reg, local_reg_translated));
+
+  operands[0] = local_reg.ToRawOperand();
+  translator()->TranslateInputRegisters(Bytecode::kStar, operands, 1);
+  EXPECT_EQ(1, move_count());
+  EXPECT_FALSE(PopMoveAndMatch(local_reg_translated, window_reg));
+  translator()->TranslateOutputRegisters();
   EXPECT_EQ(2, move_count());
   EXPECT_TRUE(PopMoveAndMatch(window_reg, local_reg_translated));
 
   Register param_reg = Register::FromParameterIndex(0, 130);
   operands[0] = {param_reg.ToRawOperand()};
   translator()->TranslateInputRegisters(Bytecode::kLdar, operands, 1);
   EXPECT_EQ(3, move_count());
   EXPECT_TRUE(PopMoveAndMatch(param_reg, window_reg));
   translator()->TranslateOutputRegisters();
+  EXPECT_EQ(3, move_count());
+  EXPECT_FALSE(PopMoveAndMatch(window_reg, param_reg));
+
+  operands[0] = {param_reg.ToRawOperand()};
+  translator()->TranslateInputRegisters(Bytecode::kStar, operands, 1);
+  EXPECT_EQ(3, move_count());
+  EXPECT_FALSE(PopMoveAndMatch(local_reg_translated, window_reg));
+  translator()->TranslateOutputRegisters();
   EXPECT_EQ(4, move_count());
   EXPECT_TRUE(PopMoveAndMatch(window_reg, param_reg));
 }
 
 TEST_F(RegisterTranslatorTest, RangeTranslation) {
   Register window0(window_start());
   Register window1(window_start() + 1);
   Register window2(window_start() + 2);
   uint32_t operands[3];
 
@@ skipping 51 matching lines @@
   uint32_t operands[] = {receiver.ToRawOperand(), index.ToRawOperand(),
                          cache_info_pair.ToRawOperand()};
   ASSERT_DEATH_IF_SUPPORTED(
       translator()->TranslateInputRegisters(Bytecode::kForInNext, operands, 3),
       kBadOperandRegex);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8