[interpreter] Wide register support.

src/interpreter/bytecodes.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/bytecodes.h"
 
 #include "src/frames.h"
 #include "src/interpreter/bytecode-traits.h"
 
 namespace v8 {
@@ skipping 39 matching lines @@
     case OperandSize::kShort:
       return "Short";
   }
   UNREACHABLE();
   return "";
 }
 
 
 // static
 uint8_t Bytecodes::ToByte(Bytecode bytecode) {
+  DCHECK(bytecode <= Bytecode::kLast);
   return static_cast<uint8_t>(bytecode);
 }
 
 
 // static
 Bytecode Bytecodes::FromByte(uint8_t value) {
   Bytecode bytecode = static_cast<Bytecode>(value);
   DCHECK(bytecode <= Bytecode::kLast);
   return bytecode;
 }
@@ skipping 23 matching lines @@
     return BytecodeTraits<__VA_ARGS__, OPERAND_TERM>::kOperandCount;
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return 0;
 }
 
 
 // static
+int Bytecodes::NumberOfRegisterOperands(Bytecode bytecode) {
+  DCHECK(bytecode <= Bytecode::kLast);
+  switch (bytecode) {
+#define CASE(Name, ...)                                            \
+  case Bytecode::k##Name:                                          \
+    typedef BytecodeTraits<__VA_ARGS__, OPERAND_TERM> Name##Trait; \
+    return Name##Trait::kRegisterOperandCount;
+    BYTECODE_LIST(CASE)
+#undef CASE
+  }
+  UNREACHABLE();
+  return false;
+}
+
+
+// static
 OperandType Bytecodes::GetOperandType(Bytecode bytecode, int i) {
   DCHECK(bytecode <= Bytecode::kLast);
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
     return BytecodeTraits<__VA_ARGS__, OPERAND_TERM>::GetOperandType(i);
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
@@ skipping 10 matching lines @@
     return BytecodeTraits<__VA_ARGS__, OPERAND_TERM>::GetOperandSize(i);
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return OperandSize::kNone;
 }
 
 
 // static
+int Bytecodes::GetRegisterOperandBitmap(Bytecode bytecode) {
+  DCHECK(bytecode <= Bytecode::kLast);
+  switch (bytecode) {
+#define CASE(Name, ...)                                            \
+  case Bytecode::k##Name:                                          \
+    typedef BytecodeTraits<__VA_ARGS__, OPERAND_TERM> Name##Trait; \
+    return Name##Trait::kRegisterOperandBitmap;
+    BYTECODE_LIST(CASE)
+#undef CASE
+  }
+  UNREACHABLE();
+  return false;
+}
+
+
+// static
 int Bytecodes::GetOperandOffset(Bytecode bytecode, int i) {
   DCHECK(bytecode <= Bytecode::kLast);
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
     return BytecodeTraits<__VA_ARGS__, OPERAND_TERM>::GetOperandOffset(i);
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
@@ skipping 213 matching lines @@
 
 static const int kLastParamRegisterIndex =
     -InterpreterFrameConstants::kLastParamFromRegisterPointer / kPointerSize;
 static const int kFunctionClosureRegisterIndex =
     -InterpreterFrameConstants::kFunctionFromRegisterPointer / kPointerSize;
 static const int kCurrentContextRegisterIndex =
     -InterpreterFrameConstants::kContextFromRegisterPointer / kPointerSize;
 static const int kNewTargetRegisterIndex =
     -InterpreterFrameConstants::kNewTargetFromRegisterPointer / kPointerSize;
 
+// The register space is a signed 16-bit space. Register operands
+// occupy range above 0. Parameter indices are biased with the
+// negative value kLastParamRegisterIndex for ease of access in the
+// interpreter.
+static const int kMaxParameterIndex = kMaxInt16 + kLastParamRegisterIndex;
+static const int kMaxRegisterIndex = -kMinInt16;
+static const int kMaxReg8Index = -kMinInt8;
+static const int kMinReg8Index = -kMaxInt8;
+static const int kMaxReg16Index = -kMinInt16;
+static const int kMinReg16Index = -kMaxInt16;
 
-// Registers occupy range 0-127 in 8-bit value leaving 128 unused values.
-// Parameter indices are biased with the negative value kLastParamRegisterIndex
-// for ease of access in the interpreter.
-static const int kMaxParameterIndex = 128 + kLastParamRegisterIndex;
+bool Register::is_byte_operand() const {
+  return index_ >= kMinReg8Index && index_ <= kMaxReg8Index;
+}
+
+
+bool Register::is_short_operand() const {
+  return index_ >= kMinReg16Index && index_ <= kMaxReg16Index;
+}
 
 
 Register Register::FromParameterIndex(int index, int parameter_count) {
   DCHECK_GE(index, 0);
   DCHECK_LT(index, parameter_count);
   DCHECK_LE(parameter_count, kMaxParameterIndex + 1);
   int register_index = kLastParamRegisterIndex - parameter_count + index + 1;
   DCHECK_LT(register_index, 0);
-  DCHECK_GE(register_index, kMinInt8);
   return Register(register_index);
 }
 
 
 int Register::ToParameterIndex(int parameter_count) const {
   DCHECK(is_parameter());
   return index() - kLastParamRegisterIndex + parameter_count - 1;
 }
 
 
@@ skipping 21 matching lines @@
 
 
 bool Register::is_new_target() const {
   return index() == kNewTargetRegisterIndex;
 }
 
 
 int Register::MaxParameterIndex() { return kMaxParameterIndex; }
 
 
+int Register::MaxRegisterIndex() { return kMaxRegisterIndex; }
+
+
+int Register::MaxRegisterIndexForByteOperand() { return kMaxReg8Index; }
+
+
 uint8_t Register::ToOperand() const {
-  DCHECK_GE(index_, kMinInt8);
-  DCHECK_LE(index_, kMaxInt8);
+  DCHECK(is_byte_operand());
   return static_cast<uint8_t>(-index_);
 }
 
 
 Register Register::FromOperand(uint8_t operand) {
   return Register(-static_cast<int8_t>(operand));
 }
 
 
 uint16_t Register::ToWideOperand() const {
-  DCHECK_GE(index_, kMinInt16);
-  DCHECK_LE(index_, kMaxInt16);
+  DCHECK(is_short_operand());
   return static_cast<uint16_t>(-index_);
 }
 
 
 Register Register::FromWideOperand(uint16_t operand) {
   return Register(-static_cast<int16_t>(operand));
 }
 
 
 uint32_t Register::ToRawOperand() const {
@@ skipping 19 matching lines @@
   }
   if (reg5.is_valid() && reg4.index() + 1 != reg5.index()) {
     return false;
   }
   return true;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8