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

test/unittests/compiler/bytecode-graph-builder-unittest.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 <iostream>
 
 #include "src/compiler/bytecode-graph-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/instruction.h"
@@ skipping 80 matching lines @@
 }
 
 
 Matcher<Node*> BytecodeGraphBuilderTest::IsTrueConstant() {
   return IsHeapConstant(factory()->true_value());
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnUndefined) {
   array_builder()->set_locals_count(0);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadUndefined().Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsUndefinedConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnNull) {
   array_builder()->set_locals_count(0);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadNull().Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   EXPECT_THAT(ret, IsReturn(IsNullConstant(), graph->start(), graph->start()));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnTheHole) {
   array_builder()->set_locals_count(0);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadTheHole().Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsTheHoleConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnTrue) {
   array_builder()->set_locals_count(0);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadTrue().Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsTrueConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnFalse) {
   array_builder()->set_locals_count(0);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadFalse().Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsFalseConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnInt8) {
   static const int kValue = 3;
   array_builder()->set_locals_count(0);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadLiteral(Smi::FromInt(kValue)).Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsNumberConstant(kValue), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnDouble) {
   const double kValue = 0.123456789;
   array_builder()->set_locals_count(0);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadLiteral(factory()->NewHeapNumber(kValue));
   array_builder()->Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsNumberConstant(kValue), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, SimpleExpressionWithParameters) {
   array_builder()->set_locals_count(1);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(3);
   array_builder()
       ->LoadAccumulatorWithRegister(array_builder()->Parameter(1))
       .BinaryOperation(Token::Value::ADD, array_builder()->Parameter(2),
                        Strength::WEAK)
       .StoreAccumulatorInRegister(interpreter::Register(0))
       .Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   // NB binary operation is <reg> <op> <acc>. The register represents
   // the left-hand side, which is why parameters appear in opposite
   // order to construction via the builder.
   EXPECT_THAT(ret, IsReturn(IsJSAdd(IsParameter(2), IsParameter(1)), _, _));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, SimpleExpressionWithRegister) {
   static const int kLeft = -655371;
   static const int kRight = +2000000;
   array_builder()->set_locals_count(1);
+  array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()
       ->LoadLiteral(Smi::FromInt(kLeft))
       .StoreAccumulatorInRegister(interpreter::Register(0))
       .LoadLiteral(Smi::FromInt(kRight))
       .BinaryOperation(Token::Value::ADD, interpreter::Register(0),
                        Strength::WEAK)
       .Return();
 
   Graph* graph = GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   EXPECT_THAT(
       ret, IsReturn(IsJSAdd(IsNumberConstant(kLeft), IsNumberConstant(kRight)),
                     _, _));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8