[interpreter] 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) {}
+
+
+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();
+    }
+    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) {
+  OperandType operand_type = Bytecodes::GetOperandType(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);
+  }
+  return addressable_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);
+    }
+    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
+bool RegisterTranslator::InTranslationWindow(Register reg) {
+  return (reg.index() >= kTranslationWindowStart &&
+          reg.index() <= kTranslationWindowLimit);
+}
+
+
+// static
+Register RegisterTranslator::UntranslateRegister(Register reg) {
+  if (reg.index() >= kTranslationWindowStart) {
+    return Register(reg.index() - kTranslationWindowLength);
+  } else {
+    return reg;
+  }
+}
+
+
+// static
+int RegisterTranslator::DistanceToTranslationWindow(Register reg) {
+  return kTranslationWindowStart - reg.index();
+}
+
+
+// static
+bool RegisterTranslator::FitsInReg8Operand(Register reg) {
+  return reg.is_byte_operand() && reg.index() < kTranslationWindowStart;
+}
+
+
+// static
+bool RegisterTranslator::FitsInReg16Operand(Register reg) {
+  int max_index = Register::MaxRegisterIndex() - kTranslationWindowLength + 1;
+  return reg.is_short_operand() && reg.index() < max_index;
+}
+
+
+// static
+int RegisterTranslator::RegisterCountAdjustment(int register_count,
+                                                int parameter_count) {
+  if (register_count > kTranslationWindowStart) {
+    return kTranslationWindowLength;
+  } else if (parameter_count > 0) {
+    Register param0 = Register::FromParameterIndex(0, parameter_count);
+    if (!param0.is_byte_operand()) {
+      // TODO(oth): Number of parameters means translation is
+      // required, but the translation window location is such that
+      // some space is wasted. Hopefully a rare corner case, but could
+      // relocate window to limit waste.
+      return kTranslationWindowLimit + 1 - register_count;
+    }
+  }
+  return 0;
+}
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8