[Interpreter] Bytecodes for exchanging registers.

src/interpreter/bytecodes.h

 // 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.
 
 #ifndef V8_INTERPRETER_BYTECODES_H_
 #define V8_INTERPRETER_BYTECODES_H_
 
 #include <iosfwd>
 
 // Clients of this interface shouldn't depend on lots of interpreter internals.
@@ skipping 11 matching lines @@
   V(None, OperandSize::kNone)      \
                                    \
   /* Byte operands. */             \
   V(Count8, OperandSize::kByte)    \
   V(Imm8, OperandSize::kByte)      \
   V(Idx8, OperandSize::kByte)      \
   V(Reg8, OperandSize::kByte)      \
   V(MaybeReg8, OperandSize::kByte) \
                                    \
   /* Short operands. */            \
+  V(Idx16, OperandSize::kShort)    \

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

nit - alphabetical ordering?

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

Done.

   V(Count16, OperandSize::kShort)  \
-  V(Idx16, OperandSize::kShort)
+  V(Reg16, OperandSize::kShort)
 
 // The list of bytecodes which are interpreted by the interpreter.
 #define BYTECODE_LIST(V)                                                       \
                                                                                \
   /* Loading the accumulator */                                                \
   V(LdaZero, OperandType::kNone)                                               \
   V(LdaSmi8, OperandType::kImm8)                                               \
   V(LdaUndefined, OperandType::kNone)                                          \
   V(LdaNull, OperandType::kNone)                                               \
   V(LdaTheHole, OperandType::kNone)                                            \
@@ skipping 27 matching lines @@
   V(LdaLookupSlotInsideTypeof, OperandType::kIdx8)                             \
   V(StaLookupSlotSloppy, OperandType::kIdx8)                                   \
   V(StaLookupSlotStrict, OperandType::kIdx8)                                   \
                                                                                \
   /* Register-accumulator transfers */                                         \
   V(Ldar, OperandType::kReg8)                                                  \
   V(Star, OperandType::kReg8)                                                  \
                                                                                \
   /* Register-register transfers */                                            \
   V(Mov, OperandType::kReg8, OperandType::kReg8)                               \
+  V(Exchange, OperandType::kReg8, OperandType::kReg16)                         \

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

Is it worth having the non-wide version? It only saves a byte, and we should
only hopefully not hit the exchange path too often (otherwise we have more to
worry about, with the extra exchange bytecodes and the extra byte here wouldn't
have much impact). WDYT?

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

I've not found a case that would need it in the next stage of this change. Also
have not found any cases that'd benefit from ExchangeWide either and will pull
it if this continues to be the case.

+  V(ExchangeWide, OperandType::kReg16, OperandType::kReg16)                    \
                                                                                \
   /* LoadIC operations */                                                      \
   V(LoadICSloppy, OperandType::kReg8, OperandType::kIdx8, OperandType::kIdx8)  \
   V(LoadICStrict, OperandType::kReg8, OperandType::kIdx8, OperandType::kIdx8)  \
   V(KeyedLoadICSloppy, OperandType::kReg8, OperandType::kIdx8)                 \
   V(KeyedLoadICStrict, OperandType::kReg8, OperandType::kIdx8)                 \
   /* TODO(rmcilroy): Wide register operands too? */                            \
   V(LoadICSloppyWide, OperandType::kReg8, OperandType::kIdx16,                 \
     OperandType::kIdx16)                                                       \
   V(LoadICStrictWide, OperandType::kReg8, OperandType::kIdx16,                 \
@@ skipping 152 matching lines @@
   kLast = -1 BYTECODE_LIST(COUNT_BYTECODE)
 #undef COUNT_BYTECODE
 };
 
 
 // An interpreter Register which is located in the function's Register file
 // in its stack-frame. Register hold parameters, this, and expression values.
 class Register {
  public:
   static const int kMaxRegisterIndex = 127;
   static const int kMinRegisterIndex = -128;

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

Can we get rid of these now? If not could we rename them more appropriately?

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

Done.

 
   Register() : index_(kIllegalIndex) {}
 
-  explicit Register(int index) : index_(index) {
-    DCHECK_LE(index_, kMaxRegisterIndex);
-    DCHECK_GE(index_, kMinRegisterIndex);
-  }
+  explicit Register(int index) : index_(index) {}
 
   int index() const {
     DCHECK(index_ != kIllegalIndex);
     return index_;
   }
   bool is_parameter() const { return index() < 0; }
   bool is_valid() const { return index_ != kIllegalIndex; }
 
   static Register FromParameterIndex(int index, int parameter_count);
   int ToParameterIndex(int parameter_count) const;
   static int MaxParameterIndex();
 
   // Returns the register for the function's closure object.
   static Register function_closure();
   bool is_function_closure() const;
 
   // Returns the register for the function's outer context.
   static Register function_context();
   bool is_function_context() const;
 
   // Returns the register for the incoming new target value.
   static Register new_target();
   bool is_new_target() const;
 
   static Register FromOperand(uint8_t operand);
   uint8_t ToOperand() const;
 
+  static Register FromWideOperand(uint16_t operand);
+  uint16_t ToWideOperand() const;
+
   static bool AreContiguous(Register reg1, Register reg2,
                             Register reg3 = Register(),
                             Register reg4 = Register(),
                             Register reg5 = Register());
 
   bool operator==(const Register& other) const {
     return index() == other.index();
   }
   bool operator!=(const Register& other) const {
     return index() != other.index();
@@ skipping 88 matching lines @@
 
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode);
 std::ostream& operator<<(std::ostream& os, const OperandType& operand_type);
 std::ostream& operator<<(std::ostream& os, const OperandSize& operand_type);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODES_H_