[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"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 class RegisterTranslatorTest : public TestWithIsolateAndZone,
                                private RegisterMover {
  public:
   RegisterTranslatorTest() : translator_(this), move_count_(0) {
     window_start_ =
         RegisterTranslator::DistanceToTranslationWindow(Register(0));
     window_width_ =
         Register::MaxRegisterIndexForByteOperand() - window_start_ + 1;
   }
 
   ~RegisterTranslatorTest() override {}
 
   bool PopMoveAndMatch(Register from, Register to) {
-    CHECK(from.is_valid() && to.is_valid());
-    const std::pair<Register, Register> top = moves_.top();
-    moves_.pop();
-    return top.first == from && top.second == to;
+    if (!moves_.empty()) {
+      CHECK(from.is_valid() && to.is_valid());
+      const std::pair<Register, Register> top = moves_.top();
+      moves_.pop();
+      return top.first == from && top.second == to;
+    } else {
+      return false;
+    }
   }
 
   int move_count() const { return move_count_; }
   RegisterTranslator* translator() { return &translator_; }
 
   int window_start() const { return window_start_; }
   int window_width() const { return window_width_; }
   int window_limit() const { return window_start_ + window_width_; }
 
  protected:
   static const char* const kBadOperandRegex;
 
  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);
-    if (operand_type == OperandType::kReg8 ||
-        operand_type == OperandType::kReg16) {
-      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\\) && "
+    "RegisterIsMovableToWindow.*";
 
 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