[Interpreter] Bytecodes for exchanging registers.

src/interpreter/bytecode-array-builder.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/bytecode-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 361 matching lines @@
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::MoveRegister(Register from,
                                                          Register to) {
   DCHECK(from != to);
   Output(Bytecode::kMov, from.ToOperand(), to.ToOperand());
   return *this;
 }
 
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::ExchangeRegisters(Register a,
+                                                              Register b) {

[rmcilroy, 2016/01/04 11:54:54]

nit - a->lhs  b->rhs (like .h file)

[oth, 2016/01/04 14:01:42]

Done.

+  if (a != b) {

[rmcilroy, 2016/01/04 11:54:54]

Should we ever call Exchange when the registers are the same? Could this be a
DCHECK instead?

[oth, 2016/01/04 14:01:42]

Done.

+    if (FitsInReg8Operand(a)) {
+      Output(Bytecode::kExchange, a.ToOperand(), b.ToWideOperand());
+    } else if (FitsInReg8Operand(b)) {
+      Output(Bytecode::kExchange, b.ToOperand(), a.ToWideOperand());
+    } else {
+      Output(Bytecode::kExchangeWide, a.ToWideOperand(), b.ToWideOperand());
+    }
+  }
+  return *this;
+}
+
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal(
     const Handle<String> name, int feedback_slot, LanguageMode language_mode,
     TypeofMode typeof_mode) {
   // TODO(rmcilroy): Potentially store language and typeof information in an
   // operand rather than having extra bytecodes.
   Bytecode bytecode = BytecodeForLoadGlobal(language_mode, typeof_mode);
   size_t name_index = GetConstantPoolEntry(name);
   if (FitsInIdx8Operand(name_index) && FitsInIdx8Operand(feedback_slot)) {
     Output(bytecode, static_cast<uint8_t>(name_index),
            static_cast<uint8_t>(feedback_slot));
@@ skipping 764 matching lines @@
         return true;
       } else if (reg.is_parameter()) {
         int parameter_index = reg.ToParameterIndex(parameter_count_);
         return parameter_index >= 0 && parameter_index < parameter_count_;
       } else if (reg.index() < fixed_register_count()) {
         return true;
       } else {
         return TemporaryRegisterIsLive(reg);
       }
     }
+    case OperandType::kReg16: {
+      if (bytecode != Bytecode::kExchange &&
+          bytecode != Bytecode::kExchangeWide) {
+        return false;
+      }
+      Register reg =
+          Register::FromWideOperand(static_cast<uint16_t>(operand_value));
+      if (reg.is_function_context() || reg.is_function_closure() ||
+          reg.is_new_target()) {

[rmcilroy, 2016/01/04 11:54:53]

Do we ever want to allow exchanges of these registers? That would seem to be a
bug (since the interpreter might assume the context / closure / etc. is in these
fixed registers).

[oth, 2016/01/04 14:01:42]

Done.

+        return true;
+      } else if (reg.is_parameter()) {
+        int parameter_index = reg.ToParameterIndex(parameter_count_);
+        return parameter_index >= 0 && parameter_index < parameter_count_;
+      } else if (reg.index() < fixed_register_count()) {
+        return true;
+      } else {
+        return TemporaryRegisterIsLive(reg);
+      }
+    }
   }
   UNREACHABLE();
   return false;
 }
 
 
 bool BytecodeArrayBuilder::LastBytecodeInSameBlock() const {
   return last_bytecode_start_ < bytecodes()->size() &&
          last_bytecode_start_ >= last_block_end_;
 }
@@ skipping 285 matching lines @@
 
 
 // static
 bool BytecodeArrayBuilder::FitsInIdx8Operand(size_t value) {
   return value <= static_cast<size_t>(kMaxUInt8);
 }
 
 
 // static
 bool BytecodeArrayBuilder::FitsInImm8Operand(int value) {
-  return kMinInt8 <= value && value < kMaxInt8;
+  return kMinInt8 <= value && value <= kMaxInt8;
 }
 
 
 // static
 bool BytecodeArrayBuilder::FitsInIdx16Operand(int value) {
   return kMinUInt16 <= value && value <= kMaxUInt16;
 }
 
 
 // static
 bool BytecodeArrayBuilder::FitsInIdx16Operand(size_t value) {
   return value <= static_cast<size_t>(kMaxUInt16);
 }
 
 
+// static
+bool BytecodeArrayBuilder::FitsInReg8Operand(Register value) {
+  return kMinInt8 <= value.index() && value.index() <= kMaxInt8;
+}
+
+
+// static
+bool BytecodeArrayBuilder::FitsInReg16Operand(Register value) {
+  return kMinInt16 <= value.index() && value.index() <= kMaxInt16;
+}
+
+
 TemporaryRegisterScope::TemporaryRegisterScope(BytecodeArrayBuilder* builder)
     : builder_(builder),
       allocated_(builder->zone()),
       next_consecutive_register_(-1),
       next_consecutive_count_(-1) {}
 
 
 TemporaryRegisterScope::~TemporaryRegisterScope() {
   for (auto i = allocated_.rbegin(); i != allocated_.rend(); i++) {
     builder_->ReturnTemporaryRegister(*i);
@@ skipping 46 matching lines @@
   DCHECK_GT(next_consecutive_count_, 0);
   builder_->BorrowConsecutiveTemporaryRegister(next_consecutive_register_);
   allocated_.push_back(next_consecutive_register_);
   next_consecutive_count_--;
   return Register(next_consecutive_register_++);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8