[interpreter] Reduce move operations for wide register support.

src/interpreter/register-translator.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/register-translator.h"
 
 #include "src/interpreter/bytecode-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 RegisterTranslator::RegisterTranslator(RegisterMover* mover)
-    : mover_(mover), emitting_moves_(false), window_registers_count_(0) {}
+    : mover_(mover),
+      emitting_moves_(false),
+      window_registers_count_(0),
+      output_moves_count_(0) {}
 
 void RegisterTranslator::TranslateInputRegisters(Bytecode bytecode,
                                                  uint32_t* raw_operands,
                                                  int raw_operand_count) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), raw_operand_count);
   if (!emitting_moves_) {
     emitting_moves_ = true;
     DCHECK_EQ(window_registers_count_, 0);
     int register_bitmap = Bytecodes::GetRegisterOperandBitmap(bytecode);
     for (int i = 0; i < raw_operand_count; i++) {
       if ((register_bitmap & (1 << i)) == 0) {
         continue;
       }
       Register in_reg = Register::FromRawOperand(raw_operands[i]);
       Register out_reg = TranslateAndMove(bytecode, i, in_reg);
       raw_operands[i] = out_reg.ToRawOperand();
     }
+    window_registers_count_ = 0;
     emitting_moves_ = false;
   } else {
     // When the register translator is translating registers, it will
     // cause the bytecode generator to emit moves on it's behalf. This
     // path is reached by these moves.
     DCHECK(bytecode == Bytecode::kMovWide && raw_operand_count == 2 &&
            Register::FromRawOperand(raw_operands[0]).is_valid() &&
            Register::FromRawOperand(raw_operands[1]).is_valid());
   }
 }
 
 Register RegisterTranslator::TranslateAndMove(Bytecode bytecode,
                                               int operand_index, Register reg) {
+  if (FitsInReg8Operand(reg)) {
+    return reg;
+  }
+
   OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
+  OperandSize operand_size = Bytecodes::SizeOfOperand(operand_type);
+  if (operand_size == OperandSize::kShort) {
+    CHECK(FitsInReg16Operand(reg));
+    return Translate(reg);
+  }
+
+  CHECK((operand_type == OperandType::kReg8 ||
+         operand_type == OperandType::kRegOut8) &&
+        mover()->RegisterOperandIsMovable(bytecode, operand_index));
   Register translated_reg = Translate(reg);
-  Register addressable_reg = MakeAddressable(translated_reg, operand_type);
-  if (addressable_reg != translated_reg) {
-    CHECK(operand_type == OperandType::kReg8 &&
-          mover()->RegisterOperandIsMovable(bytecode, operand_index));
-    mover()->MoveRegisterUntranslated(translated_reg, addressable_reg);
+  Register window_reg(kTranslationWindowStart + window_registers_count_);
+  window_registers_count_ += 1;
+  if (Bytecodes::IsRegisterInputOperandType(operand_type)) {
+    DCHECK(!Bytecodes::IsRegisterOutputOperandType(operand_type));
+    mover()->MoveRegisterUntranslated(translated_reg, window_reg);
+  } else if (Bytecodes::IsRegisterOutputOperandType(operand_type)) {
+    DCHECK_LT(output_moves_count_, kTranslationWindowLength);
+    output_moves_[output_moves_count_] =
+        std::make_pair(window_reg, translated_reg);
+    output_moves_count_ += 1;
+  } else {
+    UNREACHABLE();
   }
-  return addressable_reg;
+  return window_reg;
 }
 
 void RegisterTranslator::TranslateOutputRegisters() {
   if (!emitting_moves_) {
     emitting_moves_ = true;
-    while (window_registers_count_ > 0) {
-      window_registers_count_ -= 1;
-      Register source(kTranslationWindowStart + window_registers_count_);
-      Register destination = window_registers_[window_registers_count_];
-      mover()->MoveRegisterUntranslated(source, destination);
+    while (output_moves_count_ > 0) {
+      output_moves_count_ -= 1;
+      mover()->MoveRegisterUntranslated(
+          output_moves_[output_moves_count_].first,
+          output_moves_[output_moves_count_].second);
     }
     emitting_moves_ = false;
   }
 }
 
-Register RegisterTranslator::MakeAddressable(Register reg,
-                                             OperandType reg_type) {
-  DCHECK(!InTranslationWindow(reg));
-  OperandSize reg_size = Bytecodes::SizeOfOperand(reg_type);
-  if (reg_size == OperandSize::kByte && !FitsInReg8Operand(reg)) {
-    // TODO(oth): Moves into and out from translation window could be
-    // decoupled if there were metadata to say whether the register
-    // operand was an input, output, or input-and-output for a given
-    // bytecode.
-    Register destination(kTranslationWindowStart + window_registers_count_);
-    window_registers_[window_registers_count_] = reg;
-    window_registers_count_ += 1;
-    DCHECK_LE(window_registers_count_, kTranslationWindowLength);
-    return destination;
-  } else {
-    return reg;
-  }
-}
-
 // static
 Register RegisterTranslator::Translate(Register reg) {
   if (reg.index() >= kTranslationWindowStart) {
     return Register(reg.index() + kTranslationWindowLength);
   } else {
     return reg;
   }
 }
 
 // static
@@ skipping 41 matching lines @@
       // relocate window to limit waste.
       return kTranslationWindowLimit + 1 - register_count;
     }
   }
   return 0;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8