[interpreter]: Update BytecodeArrayBuilder register handling.

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 21 matching lines @@
   int register_count = local_register_count_ + temporary_register_count_;
   int frame_size = register_count * kPointerSize;
   Handle<BytecodeArray> output = isolate_->factory()->NewBytecodeArray(
       bytecode_size, &bytecodes_.front(), frame_size);
   bytecode_generated_ = true;
   return output;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value binop,
-                                                            int reg) {
-  Output(BytecodeForBinaryOperation(binop), reg);
+                                                            Register reg) {
+  Output(BytecodeForBinaryOperation(binop), reg.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(
     v8::internal::Smi* smi) {
   int32_t raw_smi = smi->value();
   if (raw_smi == 0) {
     Output(Bytecode::kLdaZero);
   } else if (raw_smi > -128 && raw_smi <= 128) {
@@ skipping 30 matching lines @@
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadFalse() {
   Output(Bytecode::kLdaFalse);
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadAccumulatorWithRegister(
-    int reg) {
-  Output(Bytecode::kLdar, reg);
+    Register reg) {
+  Output(Bytecode::kLdar, reg.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreAccumulatorInRegister(
-    int reg) {
-  Output(Bytecode::kStar, reg);
+    Register reg) {
+  Output(Bytecode::kStar, reg.ToOperand());
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::Return() {
   Output(Bytecode::kReturn);
   return *this;
 }
 
 
 int BytecodeArrayBuilder::BorrowTemporaryRegister() {
   DCHECK_GE(local_register_count_, 0);
-  int temporary_register = temporary_register_next_++;
+  int temporary_reg_index = temporary_register_next_++;
   int count = temporary_register_next_ - local_register_count_;
   if (count > temporary_register_count_) {
     temporary_register_count_ = count;
   }
-  return temporary_register;
+  return temporary_reg_index;
 }
 
 
-void BytecodeArrayBuilder::ReturnTemporaryRegister(int reg) {
-  DCHECK_EQ(reg, temporary_register_next_ - 1);
-  temporary_register_next_ = reg;
+void BytecodeArrayBuilder::ReturnTemporaryRegister(int reg_index) {
+  DCHECK_EQ(reg_index, temporary_register_next_ - 1);
+  temporary_register_next_ = reg_index;
 }
 
 
 bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index,
                                           uint8_t operand_value) const {
   OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
   switch (operand_type) {
     case OperandType::kNone:
       return false;
     case OperandType::kImm8:
       return true;
     case OperandType::kReg:
-      return operand_value < temporary_register_next_;
+      return Register::FromOperand(operand_value).index() <
+             temporary_register_next_;
   }
   UNREACHABLE();
   return false;
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint8_t operand0,
                                   uint8_t operand1, uint8_t operand2) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 3);
   DCHECK(OperandIsValid(bytecode, 0, operand0) &&
@@ skipping 43 matching lines @@
     case Token::Value::DIV:
       return Bytecode::kDiv;
     default:
       UNIMPLEMENTED();
       return static_cast<Bytecode>(-1);
   }
 }
 
 
 TemporaryRegisterScope::TemporaryRegisterScope(BytecodeArrayBuilder* builder)
-    : builder_(builder), count_(0), register_(-1) {}
+    : builder_(builder), count_(0), last_register_index_(-1) {}
 
 
 TemporaryRegisterScope::~TemporaryRegisterScope() {
   while (count_-- != 0) {
-    builder_->ReturnTemporaryRegister(register_--);
+    builder_->ReturnTemporaryRegister(last_register_index_--);
   }
 }
 
 
-int TemporaryRegisterScope::NewRegister() {
+Register TemporaryRegisterScope::NewRegister() {
   count_++;
-  register_ = builder_->BorrowTemporaryRegister();
-  return register_;
+  last_register_index_ = builder_->BorrowTemporaryRegister();
+  return Register(last_register_index_);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8