[Intepreter] Extend and move Register class.

test/unittests/interpreter/bytecodes-unittest.cc

+// Copyright 2014 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/v8.h"
+
+#include "src/interpreter/bytecode-array-builder.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+TEST(OperandConversion, Registers) {
+  for (int i = 0; i < 128; i++) {
+    uint8_t operand_value = Bytecodes::RegisterIndexToOperand(i);
+    uint8_t index = Bytecodes::RegisterIndexFromOperand(operand_value);
+    CHECK_EQ(i, index);
+  }
+}
+
+
+TEST(OperandConversion, Parameters) {
+  int parameter_counts[] = {7, 13, 99};

[rmcilroy, 2015/09/02 11:42:42]

nit - could you just use a std::vector here instead of having to define
COUNT_OF?

[oth, 2015/09/02 14:02:20]

Done. With uniform initialization, this is a fine idea (std::array even). Chrome
rules seem to be against it, but see it in use elsewhere in v8 tests.

+#define COUNT_OF(x) static_cast<int>(sizeof(x) / sizeof(x[0]))
+  for (int p = 0; p < COUNT_OF(parameter_counts); p++) {
+    int parameter_count = parameter_counts[p];
+    for (int i = 0; i <= parameter_count; i++) {
+      uint8_t operand_value =
+          Bytecodes::ParameterIndexToOperand(i, parameter_count);
+      uint8_t index =
+          Bytecodes::ParameterIndexFromOperand(operand_value, parameter_count);
+      CHECK_EQ(i, index);
+    }
+  }
+#undef COUNT_OF
+}
+
+
+TEST(OperandConversion, RegistersParametersNoOverlap) {
+  uint8_t operand_count[255] = {0};
+
+  for (int i = 0; i < 128; i++) {

[rmcilroy, 2015/09/02 11:42:42]

nit - /s/128/kMaxRegisterIndex

[oth, 2015/09/02 14:02:20]

Done.

+    uint8_t register_operand = Bytecodes::RegisterIndexToOperand(i);
+    operand_count[register_operand] += 1;
+    CHECK_EQ(operand_count[register_operand], 1);
+  }
+
+  int parameter_count = Bytecodes::MaximumNumberOfParameters();
+  for (int i = 0; i <= parameter_count; i++) {
+    uint8_t parameter_operand =
+        Bytecodes::ParameterIndexToOperand(i, parameter_count);
+    operand_count[parameter_operand] += 1;
+    CHECK_EQ(operand_count[parameter_operand], 1);
+  }
+}
+
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8