[Interpreter] Add support for local context loads and stores.

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 14 matching lines @@
       temporary_register_next_(0) {}
 
 
 void BytecodeArrayBuilder::set_locals_count(int number_of_locals) {
   local_register_count_ = number_of_locals;
   DCHECK_LE(context_register_count_, 0);
   temporary_register_next_ = local_register_count_;
 }
 
 
-int BytecodeArrayBuilder::locals_count() const { return local_register_count_; }
-
-
 void BytecodeArrayBuilder::set_parameter_count(int number_of_parameters) {
   parameter_count_ = number_of_parameters;
 }
 
 
-int BytecodeArrayBuilder::parameter_count() const { return parameter_count_; }
-
-
 void BytecodeArrayBuilder::set_context_count(int number_of_contexts) {
   context_register_count_ = number_of_contexts;
   DCHECK_GE(local_register_count_, 0);
   temporary_register_next_ = local_register_count_ + context_register_count_;
 }
 
 
 Register BytecodeArrayBuilder::first_context_register() const {
   DCHECK_GT(context_register_count_, 0);
   return Register(local_register_count_);
 }
 
 
 Register BytecodeArrayBuilder::last_context_register() const {
   DCHECK_GT(context_register_count_, 0);
   return Register(local_register_count_ + context_register_count_ - 1);
 }
 
 
 Register BytecodeArrayBuilder::Parameter(int parameter_index) const {
   DCHECK_GE(parameter_index, 0);
-  DCHECK_LT(parameter_index, parameter_count_);
-  return Register::FromParameterIndex(parameter_index, parameter_count_);
+  return Register::FromParameterIndex(parameter_index, parameter_count());
 }
 
 
 Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray() {
   DCHECK_EQ(bytecode_generated_, false);
-  DCHECK_GE(parameter_count_, 0);
-  DCHECK_GE(local_register_count_, 0);
 
   EnsureReturn();
 
   int bytecode_size = static_cast<int>(bytecodes_.size());
-  int register_count = local_register_count_ + temporary_register_count_;
+  int register_count = fixed_register_count() + temporary_register_count_;
   int frame_size = register_count * kPointerSize;
 
   Factory* factory = isolate_->factory();
   int constants_count = static_cast<int>(constants_.size());
   Handle<FixedArray> constant_pool =
       factory->NewFixedArray(constants_count, TENURED);
   for (int i = 0; i < constants_count; i++) {
     constant_pool->set(i, *constants_[i]);
   }
 
   Handle<BytecodeArray> output =
       factory->NewBytecodeArray(bytecode_size, &bytecodes_.front(), frame_size,
-                                parameter_count_, constant_pool);
+                                parameter_count(), constant_pool);
   bytecode_generated_ = true;
   return output;
 }
 
 
 template <size_t N>
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint32_t(&operands)[N]) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), static_cast<int>(N));
   last_bytecode_start_ = bytecodes()->size();
   bytecodes()->push_back(Bytecodes::ToByte(bytecode));
@@ skipping 180 matching lines @@
   if (FitsInIdx8Operand(slot_index)) {
     Output(Bytecode::kLdaContextSlot, context.ToOperand(),
            static_cast<uint8_t>(slot_index));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::StoreContextSlot(Register context,
+                                                             int slot_index) {
+  DCHECK(slot_index >= 0);
+  if (FitsInIdx8Operand(slot_index)) {
+    Output(Bytecode::kStaContextSlot, context.ToOperand(),
+           static_cast<uint8_t>(slot_index));
+  } else {
+    UNIMPLEMENTED();
+  }
+  return *this;
+}
+
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty(
     Register object, int feedback_slot, LanguageMode language_mode) {
   Bytecode bytecode = BytecodeForLoadIC(language_mode);
   if (FitsInIdx8Operand(feedback_slot)) {
     Output(bytecode, object.ToOperand(), static_cast<uint8_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
@@ skipping 319 matching lines @@
     entry = constants_map_.Get(object);
     *entry = constants_.size();
     constants_.push_back(object);
   }
   DCHECK(constants_[*entry].is_identical_to(object));
   return *entry;
 }
 
 
 int BytecodeArrayBuilder::BorrowTemporaryRegister() {
-  DCHECK_GE(local_register_count_, 0);
   int temporary_reg_index = temporary_register_next_++;
-  int count = temporary_register_next_ - local_register_count_;
+  int count = temporary_register_next_ - fixed_register_count();
   if (count > temporary_register_count_) {
     temporary_register_count_ = count;
   }
   return temporary_reg_index;
 }
 
 
 void BytecodeArrayBuilder::ReturnTemporaryRegister(int reg_index) {
   DCHECK_EQ(reg_index, temporary_register_next_ - 1);
   temporary_register_next_ = reg_index;
@@ skipping 10 matching lines @@
       return static_cast<uint16_t>(operand_value) == operand_value;
     case OperandType::kCount8:
     case OperandType::kImm8:
     case OperandType::kIdx8:
       return static_cast<uint8_t>(operand_value) == operand_value;
     case OperandType::kReg8: {
       Register reg = Register::FromOperand(static_cast<uint8_t>(operand_value));
       if (reg.is_function_context() || reg.is_function_closure()) {
         return true;
       } else if (reg.is_parameter()) {
-        int parameter_index = reg.ToParameterIndex(parameter_count_);
-        return parameter_index >= 0 && parameter_index < parameter_count_;
+        int parameter_index = reg.ToParameterIndex(parameter_count());
+        return parameter_index >= 0 && parameter_index < parameter_count();
       } else {
         return (reg.index() >= 0 && reg.index() < temporary_register_next_);
       }
     }
   }
   UNREACHABLE();
   return false;
 }
 
 bool BytecodeArrayBuilder::LastBytecodeInSameBlock() const {
@@ skipping 167 matching lines @@
 
 Register TemporaryRegisterScope::NewRegister() {
   count_++;
   last_register_index_ = builder_->BorrowTemporaryRegister();
   return Register(last_register_index_);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8