[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), window_registers_count_(0), register_operands_count_(0) {}
+
+
+Register RegisterTranslator::Translate(Bytecode bytecode, Register reg) {
+  if (register_operands_count_ == 0) {
+    bytecode_ = bytecode;
+  }
+  DCHECK_EQ(bytecode, bytecode_);

[rmcilroy, 2016/01/22 17:50:57]

I'm not sure what the point of passing bytecode to this function is? is it just
for this check? Seems unnecessary since the RegisterTranslator is explicitly
created in the same function as is outputting the bytecode.

+  DCHECK_LT(register_operands_count_,
+            static_cast<int>(arraysize(register_operands_)));
+  OperandType operand_type =
+      GetRegisterOperandType(bytecode, register_operands_count_);
+  Register translated_reg = Translate(reg);
+  Register addressable = MakeAddressable(translated_reg, operand_type);
+  register_operands_[register_operands_count_] = addressable.ToRawOperand();

[rmcilroy, 2016/01/22 17:50:57]

Do we need to keep the register_operands_ in vector? It only seems to be used
for a DCHECK, and I think that if we do the pattern above where the
translator.ToRawOperand(reg) happens in the arguments to the output then there
is less need to make sure that we pass translated arguments (e.g., make the
check that register_operands_count_ ==
Bytecodes::NumberOfRegisterOperands(bytecode).

If you really want to keep this, then move it behind a DEBUG #ifdef.

+  register_operands_count_ += 1;
+  if (addressable != translated_reg) {
+    Move(translated_reg, addressable, operand_type);
+  }
+  return addressable;
+}
+
+
+Register RegisterTranslator::MakeAddressable(Register translated_reg,
+                                             OperandType translated_reg_type) {
+  DCHECK(!InTranslationWindow(translated_reg));
+  OperandSize translated_reg_size =
+      Bytecodes::SizeOfOperand(translated_reg_type);
+  if (translated_reg_size == OperandSize::kByte &&
+      !FitsInReg8Operand(translated_reg)) {
+    // TODO(oth): Moves into and out from translation window could be
+    // decoupled if there were metadata to say whether the register was
+    // an input, output, or both.
+    Register destination(kTranslationWindowStart + window_registers_count_);
+    window_registers_[window_registers_count_] = translated_reg;
+    window_registers_count_ += 1;
+    DCHECK_LE(window_registers_count_, kTranslationWindowLength);
+    return destination;
+  } else {
+    return translated_reg;
+  }
+}
+
+
+void RegisterTranslator::Move(Register from, Register to,
+                              OperandType to_operand_type) {
+  bool expect_movable = true;
+  if (to_operand_type != OperandType::kReg8) {
+    // Only tests should visit this path.

[rmcilroy, 2016/01/22 17:50:57]

What test kick this path? It seems non-obvious that this function won't actually
do a move unless the operand type is kReg8. Maybe just add a check in Translate
that does:
  if (addressable != translated_reg && to_operand_type == kReg8) {
    mover()->MoveRegisterUntranslated(from, to);
  }
- or just add a DCHECK that to_operand_type is kReg8 in this case?

+    from = to = Register::IllegalRegister();
+    expect_movable = false;
+  }
+
+  bool movable = mover()->MoveRegisterUntranslated(from, to);
+  CHECK_EQ(expect_movable, movable);
+}
+
+
+void RegisterTranslator::CompleteTranslations() {
+  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);
+  }
+  register_operands_count_ = 0;
+  bytecode_ = static_cast<Bytecode>(-1);
+}
+
+
+bool RegisterTranslator::RegisterOperandsValid(Bytecode bytecode,
+                                               const uint32_t* const operands,
+                                               int operands_count) const {
+  if (bytecode != bytecode_ && bytecode == Bytecode::kMovWide) {
+    // Checking move emitted by register translator for bytecode_.
+    DCHECK_EQ(operands_count, 2);
+    Register from = Register::FromRawOperand(operands[0]);
+    Register to = Register::FromRawOperand(operands[1]);
+    return MoveIsValid(from, to);
+  } else if (register_operands_count_ == 0) {
+    DCHECK_EQ(Bytecodes::NumberOfRegisterOperands(bytecode), 0);
+    return true;
+  }
+
+  int reg_count = 0;
+  for (int i = 0; i < operands_count; i++) {
+    OperandType operand_type = Bytecodes::GetOperandType(bytecode, i);
+    bool next_operand_is_reg_count = false;
+    if (i != operands_count - 1) {
+      OperandType next_operand_type =
+          Bytecodes::GetOperandType(bytecode, i + 1);
+      next_operand_is_reg_count =
+          next_operand_type == OperandType::kRegCount8 ||
+          next_operand_type == OperandType::kRegCount16;

[rmcilroy, 2016/01/22 17:50:57]

You don't seem to use next_operand_is_reg_count ?

+    }
+
+    Register reg;
+    int length = 0;
+    switch (operand_type) {
+      case OperandType::kNone:
+        UNREACHABLE();
+        return false;
+      case OperandType::kIdx8:
+      case OperandType::kIdx16:
+      case OperandType::kImm8:
+      case OperandType::kRegCount8:
+      case OperandType::kRegCount16:
+        break;
+      case OperandType::kMaybeReg8:
+      case OperandType::kMaybeReg16: {
+        DCHECK(next_operand_is_reg_count);
+        reg = Register::FromRawOperand(operands[i]);
+        length = static_cast<int>(operands[i + 1]);
+        break;
+      }
+      case OperandType::kRegPair8:
+      case OperandType::kRegPair16: {
+        reg = Register::FromRawOperand(operands[i]);
+        length = 2;
+        break;
+      }
+      case OperandType::kRegTriple8:
+      case OperandType::kRegTriple16: {
+        reg = Register::FromRawOperand(operands[i]);
+        length = 3;
+        break;
+      }
+      case OperandType::kReg8:
+      case OperandType::kReg16: {
+        reg = Register::FromRawOperand(operands[i]);
+        if (next_operand_is_reg_count) {
+          length = static_cast<int>(operands[i + 1]);
+        } else {
+          length = 1;
+        }
+        break;
+      }
+    }
+    if (reg.is_valid()) {
+      if (reg.ToRawOperand() != register_operands_[reg_count]) {
+        return false;
+      } else if (reg.index() < kTranslationWindowStart &&
+                 reg.index() + length > kTranslationWindowStart) {
+        return false;
+      }
+      reg_count++;
+    }
+  }
+  return reg_count == Bytecodes::NumberOfRegisterOperands(bytecode) &&
+         reg_count == register_operands_count_;
+}
+
+
+bool RegisterTranslator::MoveIsValid(Register from, Register to) const {
+  // Checking a move bytecode ahead of emitting actual bytecode. The move
+  // is ensuring all register operands are reachable.
+  if (InTranslationWindow(to)) {
+    // Moving register into translation window.
+    DCHECK(!FitsInReg8Operand(from));
+    DCHECK(from.index() > kTranslationWindowLimit || !from.is_byte_operand());
+    DCHECK_GT(window_registers_count_, 0);
+    DCHECK_LE(window_registers_count_,
+              static_cast<int>(arraysize(window_registers_)));
+    Register last_window_register =
+        window_registers_[window_registers_count_ - 1];
+    return from == last_window_register;
+  } else if (InTranslationWindow(from)) {
+    // Moving register out of translation window.
+    DCHECK(!FitsInReg8Operand(to));
+    DCHECK(to.index() > kTranslationWindowLimit || !to.is_byte_operand());
+    DCHECK_GE(window_registers_count_, 0);
+    DCHECK_LT(window_registers_count_,
+              static_cast<int>(arraysize(window_registers_)));
+    Register last_window_register = window_registers_[window_registers_count_];
+    return to == last_window_register;
+  } else {
+    UNREACHABLE();
+    return false;
+  }
+}
+
+
+// static
+Register RegisterTranslator::Translate(Register reg) {
+  if (reg.index() >= kTranslationWindowStart) {
+    return Register(reg.index() + kTranslationWindowLength);

[rmcilroy, 2016/01/22 17:50:57]

I wonder whether we should have a TranslatedRegister type just to differentiate
them and ensure we don't accidentally use the wrong type. Not sure how invasive
this would be (feel free to make it a TODO for another CL if you agree but it
would be invasive). WDYT?

+  } else {
+    return reg;
+  }
+}
+
+
+// static
+OperandType RegisterTranslator::GetRegisterOperandType(Bytecode bytecode,
+                                                       int register_operand) {
+  int operand_count = Bytecodes::NumberOfOperands(bytecode);
+  for (int operand = 0; operand < operand_count; ++operand) {

[rmcilroy, 2016/01/22 17:50:56]

Would it be possible to calculate this statically using bytecode traits? As an
alternative, maybe you could keep track of the current operand_index (and update
it in this loop) so that you continue from the previous operand index point
rather than starting from the start each time?

+    OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand);
+    switch (operand_type) {
+#define REGISTER_OPERAND_CASE(op, _) case OperandType::k##op:
+      REGISTER_OPERAND_TYPE_LIST(REGISTER_OPERAND_CASE)
+#undef REGISTER_OPERAND_CASE
+      if (register_operand-- == 0) {
+        return operand_type;
+      }
+      break;
+      default:
+        break;
+    }
+  }
+  UNREACHABLE();
+  return OperandType::kNone;
+}
+
+
+// static
+bool RegisterTranslator::InTranslationWindow(Register reg) {
+  return (reg.index() >= kTranslationWindowStart &&
+          reg.index() <= kTranslationWindowLimit);
+}
+
+
+// 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);
+    DCHECK_LT(param0.index(), 0);
+    if (param0.index() < kMinInt8) {
+      // TODO(oth): Translation window does not relocate when number of
+      // registers is small, but number of parameters is large enough to
+      // require translation. The frame may be 128 registers too large.
+      return kTranslationWindowLimit + 1 - register_count;
+    }
+  }
+  return 0;
+}
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8