[Interpreter] Bytecodes for exchanging registers.

src/interpreter/bytecode-array-builder.cc

Index: src/interpreter/bytecode-array-builder.cc
diff --git a/src/interpreter/bytecode-array-builder.cc b/src/interpreter/bytecode-array-builder.cc
index 4ec2d1264b30f9b04e3c5a7ab40d44d42ca12819..1d6b9e6ea43eee38adc749a7243bd3e4ce949046 100644
--- a/src/interpreter/bytecode-array-builder.cc
+++ b/src/interpreter/bytecode-array-builder.cc
@@ -379,6 +379,21 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::MoveRegister(Register from,
 }
 
 
+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) {
@@ -1163,6 +1178,25 @@ bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index,
         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;
@@ -1468,7 +1502,7 @@ bool BytecodeArrayBuilder::FitsInIdx8Operand(size_t value) {
 
 // static
 bool BytecodeArrayBuilder::FitsInImm8Operand(int value) {
-  return kMinInt8 <= value && value < kMaxInt8;
+  return kMinInt8 <= value && value <= kMaxInt8;
 }
 
 
@@ -1484,6 +1518,18 @@ bool BytecodeArrayBuilder::FitsInIdx16Operand(size_t value) {
 }
 
 
+// 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()),