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

test/unittests/interpreter/bytecode-array-builder-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 "src/interpreter/bytecode-array-iterator.h"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 class BytecodeArrayBuilderTest : public TestWithIsolateAndZone {
  public:
   BytecodeArrayBuilderTest() {}
   ~BytecodeArrayBuilderTest() override {}
 };
 
 
 TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
   BytecodeArrayBuilder builder(isolate(), zone());
 
   builder.set_locals_count(1);
+  builder.set_context_count(1);
   builder.set_parameter_count(0);
   CHECK_EQ(builder.locals_count(), 1);
+  CHECK_EQ(builder.context_count(), 1);
+  CHECK_EQ(builder.fixed_register_count(), 2);
 
   // Emit constant loads.
   builder.LoadLiteral(Smi::FromInt(0))
       .LoadLiteral(Smi::FromInt(8))
       .LoadLiteral(Smi::FromInt(10000000))
       .LoadUndefined()
       .LoadNull()
       .LoadTheHole()
       .LoadTrue()
       .LoadFalse();
 
   // Emit accumulator transfers.
   Register reg(0);
   builder.LoadAccumulatorWithRegister(reg).StoreAccumulatorInRegister(reg);
 
   // Emit global load / store operations.
   builder.LoadGlobal(1);
   builder.StoreGlobal(1, LanguageMode::SLOPPY);
 
   // Emit context operations.
   builder.PushContext(reg);
   builder.PopContext(reg);
   builder.LoadContextSlot(reg, 1);
+  builder.StoreContextSlot(reg, 1);
 
   // Emit load / store property operations.
   builder.LoadNamedProperty(reg, 0, LanguageMode::SLOPPY)
       .LoadKeyedProperty(reg, 0, LanguageMode::SLOPPY)
       .StoreNamedProperty(reg, reg, 0, LanguageMode::SLOPPY)
       .StoreKeyedProperty(reg, reg, 0, LanguageMode::SLOPPY)
       .LoadNamedProperty(reg, 0, LanguageMode::STRICT)
       .LoadKeyedProperty(reg, 0, LanguageMode::STRICT)
       .StoreNamedProperty(reg, reg, 0, LanguageMode::STRICT)
       .StoreKeyedProperty(reg, reg, 0, LanguageMode::STRICT);
@@ skipping 62 matching lines @@
   // Longer jumps requiring Constant operand
   builder.Jump(&start)
       .JumpIfTrue(&start)
       .JumpIfFalse(&start)
       .JumpIfToBooleanTrue(&start)
       .JumpIfToBooleanFalse(&start);
   builder.Return();
 
   // Generate BytecodeArray.
   Handle<BytecodeArray> the_array = builder.ToBytecodeArray();
-  CHECK_EQ(the_array->frame_size(), builder.locals_count() * kPointerSize);
+  CHECK_EQ(the_array->frame_size(),
+           builder.fixed_register_count() * kPointerSize);
 
   // Build scorecard of bytecodes encountered in the BytecodeArray.
   std::vector<int> scorecard(Bytecodes::ToByte(Bytecode::kLast) + 1);
   Bytecode final_bytecode = Bytecode::kLdaZero;
   int i = 0;
   while (i < the_array->length()) {
     uint8_t code = the_array->get(i);
     scorecard[code] += 1;
     final_bytecode = Bytecodes::FromByte(code);
     i += Bytecodes::Size(Bytecodes::FromByte(code));
   }
 
   // Check return occurs at the end and only once in the BytecodeArray.
   CHECK_EQ(final_bytecode, Bytecode::kReturn);
   CHECK_EQ(scorecard[Bytecodes::ToByte(final_bytecode)], 1);
 
 #define CHECK_BYTECODE_PRESENT(Name, ...)     \
   /* Check Bytecode is marked in scorecard */ \
   CHECK_GE(scorecard[Bytecodes::ToByte(Bytecode::k##Name)], 1);
   BYTECODE_LIST(CHECK_BYTECODE_PRESENT)
 #undef CHECK_BYTECODE_PRESENT
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, FrameSizesLookGood) {
   for (int locals = 0; locals < 5; locals++) {
-    for (int temps = 0; temps < 3; temps++) {
-      BytecodeArrayBuilder builder(isolate(), zone());
-      builder.set_parameter_count(0);
-      builder.set_locals_count(locals);
-      builder.Return();
+    for (int contexts = 0; contexts < 4; contexts++) {
+      for (int temps = 0; temps < 3; temps++) {
+        BytecodeArrayBuilder builder(isolate(), zone());
+        builder.set_parameter_count(0);
+        builder.set_locals_count(locals);
+        builder.set_context_count(contexts);
+        builder.Return();
 
-      TemporaryRegisterScope temporaries(&builder);
-      for (int i = 0; i < temps; i++) {
-        temporaries.NewRegister();
+        TemporaryRegisterScope temporaries(&builder);
+        for (int i = 0; i < temps; i++) {
+          temporaries.NewRegister();
+        }
+
+        Handle<BytecodeArray> the_array = builder.ToBytecodeArray();
+        int total_registers = locals + contexts + temps;
+        CHECK_EQ(the_array->frame_size(), total_registers * kPointerSize);
       }
-
-      Handle<BytecodeArray> the_array = builder.ToBytecodeArray();
-      int total_registers = locals + temps;
-      CHECK_EQ(the_array->frame_size(), total_registers * kPointerSize);
     }
   }
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, TemporariesRecycled) {
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(0);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.Return();
 
   int first;
   {
     TemporaryRegisterScope temporaries(&builder);
     first = temporaries.NewRegister().index();
     temporaries.NewRegister();
     temporaries.NewRegister();
     temporaries.NewRegister();
   }
@@ skipping 20 matching lines @@
 
   int actual_index = Register::FromOperand(actual_operand).index();
   CHECK_EQ(actual_index, index);
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, Parameters) {
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(10);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
 
   Register param0(builder.Parameter(0));
   Register param9(builder.Parameter(9));
   CHECK_EQ(param9.index() - param0.index(), 9);
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, Constants) {
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(0);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
 
   Factory* factory = isolate()->factory();
   Handle<HeapObject> heap_num_1 = factory->NewHeapNumber(3.14);
   Handle<HeapObject> heap_num_2 = factory->NewHeapNumber(5.2);
   Handle<Object> large_smi(Smi::FromInt(0x12345678), isolate());
   Handle<HeapObject> heap_num_2_copy(*heap_num_2);
   builder.LoadLiteral(heap_num_1)
       .LoadLiteral(heap_num_2)
       .LoadLiteral(large_smi)
       .LoadLiteral(heap_num_1)
       .LoadLiteral(heap_num_1)
       .LoadLiteral(heap_num_2_copy);
 
   Handle<BytecodeArray> array = builder.ToBytecodeArray();
   // Should only have one entry for each identical constant.
   CHECK_EQ(array->constant_pool()->length(), 3);
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, ForwardJumps) {
   static const int kFarJumpDistance = 256;
 
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(0);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
 
   BytecodeLabel far0, far1, far2;
   BytecodeLabel near0, near1, near2;
 
   builder.Jump(&near0)
       .JumpIfTrue(&near1)
       .JumpIfFalse(&near2)
       .Bind(&near0)
       .Bind(&near1)
       .Bind(&near2)
@@ skipping 48 matching lines @@
                  Smi::cast(*iterator.GetConstantForIndexOperand(0))->value()),
       Bytecodes::ToByte(Bytecode::kReturn));
   iterator.Advance();
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, BackwardJumps) {
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(0);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
 
   BytecodeLabel label0, label1, label2;
   builder.Bind(&label0)
       .Jump(&label0)
       .Bind(&label1)
       .JumpIfTrue(&label1)
       .Bind(&label2)
       .JumpIfFalse(&label2);
   for (int i = 0; i < 64; i++) {
     builder.Jump(&label2);
@@ skipping 31 matching lines @@
   CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
   iterator.Advance();
   CHECK(iterator.done());
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, LabelReuse) {
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(0);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
 
   // Labels can only have 1 forward reference, but
   // can be referred to mulitple times once bound.
   BytecodeLabel label;
 
   builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label).Return();
 
   Handle<BytecodeArray> array = builder.ToBytecodeArray();
   BytecodeArrayIterator iterator(array);
   CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump);
@@ skipping 10 matching lines @@
   CHECK(iterator.done());
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, LabelAddressReuse) {
   static const int kRepeats = 3;
 
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(0);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
 
   for (int i = 0; i < kRepeats; i++) {
     BytecodeLabel label;
     builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label);
   }
 
   builder.Return();
 
   Handle<BytecodeArray> array = builder.ToBytecodeArray();
   BytecodeArrayIterator iterator(array);
@@ skipping 11 matching lines @@
   CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
   iterator.Advance();
   CHECK(iterator.done());
 }
 
 
 TEST_F(BytecodeArrayBuilderTest, ToBoolean) {
   BytecodeArrayBuilder builder(isolate(), zone());
   builder.set_parameter_count(0);
   builder.set_locals_count(0);
+  builder.set_context_count(0);
 
   // Check ToBoolean emitted at start of block.
   builder.EnterBlock().CastAccumulatorToBoolean();
 
   // Check ToBoolean emitted preceding bytecode is non-boolean.
   builder.LoadNull().CastAccumulatorToBoolean();
 
   // Check ToBoolean omitted if preceding bytecode is boolean.
   builder.LoadFalse().CastAccumulatorToBoolean();
 
@@ skipping 26 matching lines @@
 
   CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
   iterator.Advance();
   CHECK(iterator.done());
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8