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

test/cctest/interpreter/test-interpreter.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/v8.h"
 
 #include "src/execution.h"
 #include "src/handles.h"
 #include "src/interpreter/bytecode-array-builder.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 154 matching lines @@
 using v8::internal::Token;
 using namespace v8::internal::interpreter;
 
 TEST(InterpreterReturn) {
   HandleAndZoneScope handles;
   Handle<Object> undefined_value =
       handles.main_isolate()->factory()->undefined_value();
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK(return_val.is_identical_to(undefined_value));
 }
 
 
 TEST(InterpreterLoadUndefined) {
   HandleAndZoneScope handles;
   Handle<Object> undefined_value =
       handles.main_isolate()->factory()->undefined_value();
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadUndefined().Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK(return_val.is_identical_to(undefined_value));
 }
 
 
 TEST(InterpreterLoadNull) {
   HandleAndZoneScope handles;
   Handle<Object> null_value = handles.main_isolate()->factory()->null_value();
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadNull().Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK(return_val.is_identical_to(null_value));
 }
 
 
 TEST(InterpreterLoadTheHole) {
   HandleAndZoneScope handles;
   Handle<Object> the_hole_value =
       handles.main_isolate()->factory()->the_hole_value();
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadTheHole().Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK(return_val.is_identical_to(the_hole_value));
 }
 
 
 TEST(InterpreterLoadTrue) {
   HandleAndZoneScope handles;
   Handle<Object> true_value = handles.main_isolate()->factory()->true_value();
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadTrue().Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK(return_val.is_identical_to(true_value));
 }
 
 
 TEST(InterpreterLoadFalse) {
   HandleAndZoneScope handles;
   Handle<Object> false_value = handles.main_isolate()->factory()->false_value();
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadFalse().Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK(return_val.is_identical_to(false_value));
 }
 
 
 TEST(InterpreterLoadLiteral) {
   HandleAndZoneScope handles;
   i::Factory* factory = handles.main_isolate()->factory();
 
   // Small Smis.
   for (int i = -128; i < 128; i++) {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     builder.LoadLiteral(Smi::FromInt(i)).Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_val = callable().ToHandleChecked();
     CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(i));
   }
 
   // Large Smis.
   {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     builder.LoadLiteral(Smi::FromInt(0x12345678)).Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_val = callable().ToHandleChecked();
     CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(0x12345678));
   }
 
   // Heap numbers.
   {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     builder.LoadLiteral(factory->NewHeapNumber(-2.1e19)).Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_val = callable().ToHandleChecked();
     CHECK_EQ(i::HeapNumber::cast(*return_val)->value(), -2.1e19);
   }
 
   // Strings.
   {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     Handle<i::String> string = factory->NewStringFromAsciiChecked("String");
     builder.LoadLiteral(string).Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_val = callable().ToHandleChecked();
     CHECK(i::String::cast(*return_val)->Equals(*string));
   }
 }
 
 
 TEST(InterpreterLoadStoreRegisters) {
   HandleAndZoneScope handles;
   Handle<Object> true_value = handles.main_isolate()->factory()->true_value();
   for (int i = 0; i <= Register::kMaxRegisterIndex; i++) {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(i + 1);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     Register reg(i);
     builder.LoadTrue()
         .StoreAccumulatorInRegister(reg)
         .LoadFalse()
         .LoadAccumulatorWithRegister(reg)
         .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
@@ skipping 65 matching lines @@
   int lhs_inputs[] = {0, -17, -182, 1073741823, -1};
   int rhs_inputs[] = {5, 2, 1, -1, -2, 0, 31, 32, -32, 64, 37};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kShiftOperators); o++) {
         HandleAndZoneScope handles;
         i::Factory* factory = handles.main_isolate()->factory();
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone());
         builder.set_locals_count(1);
+        builder.set_context_count(0);
         builder.set_parameter_count(1);
         Register reg(0);
         int lhs = lhs_inputs[l];
         int rhs = rhs_inputs[r];
         builder.LoadLiteral(Smi::FromInt(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(Smi::FromInt(rhs))
             .BinaryOperation(kShiftOperators[o], reg, Strength::WEAK)
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ skipping 14 matching lines @@
   int lhs_inputs[] = {3266, 1024, 0, -17, -18000};
   int rhs_inputs[] = {3266, 5, 4, 3, 2, 1, -1, -2};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
         HandleAndZoneScope handles;
         i::Factory* factory = handles.main_isolate()->factory();
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone());
         builder.set_locals_count(1);
+        builder.set_context_count(0);
         builder.set_parameter_count(1);
         Register reg(0);
         int lhs = lhs_inputs[l];
         int rhs = rhs_inputs[r];
         builder.LoadLiteral(Smi::FromInt(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(Smi::FromInt(rhs))
             .BinaryOperation(kArithmeticOperators[o], reg, Strength::WEAK)
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ skipping 15 matching lines @@
   double rhs_inputs[] = {3266.101, 5.999, 4.778, 3.331,  2.643,
                          1.1,      -1.8,  -2.9,  8.3e-27};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
         HandleAndZoneScope handles;
         i::Factory* factory = handles.main_isolate()->factory();
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone());
         builder.set_locals_count(1);
+        builder.set_context_count(0);
         builder.set_parameter_count(1);
         Register reg(0);
         double lhs = lhs_inputs[l];
         double rhs = rhs_inputs[r];
         builder.LoadLiteral(factory->NewNumber(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(factory->NewNumber(rhs))
             .BinaryOperation(kArithmeticOperators[o], reg, Strength::WEAK)
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ skipping 38 matching lines @@
        factory->NewStringFromStaticChars("1.112.5")},
       {factory->NewStringFromStaticChars("-1.11"), factory->NewHeapNumber(2.56),
        factory->NewStringFromStaticChars("-1.112.56")},
       {factory->NewStringFromStaticChars(""), factory->NewHeapNumber(2.5),
        factory->NewStringFromStaticChars("2.5")},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(1);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     Register reg(0);
     builder.LoadLiteral(test_cases[i].lhs)
         .StoreAccumulatorInRegister(reg)
         .LoadLiteral(test_cases[i].rhs)
         .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK)
         .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*test_cases[i].expected_value));
   }
 }
 
 
 TEST(InterpreterParameter1) {
   HandleAndZoneScope handles;
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadAccumulatorWithRegister(builder.Parameter(0)).Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<Handle<Object>>();
 
   // Check for heap objects.
   Handle<Object> true_value = handles.main_isolate()->factory()->true_value();
   Handle<Object> return_val = callable(true_value).ToHandleChecked();
   CHECK(return_val.is_identical_to(true_value));
 
   // Check for Smis.
   return_val = callable(Handle<Smi>(Smi::FromInt(3), handles.main_isolate()))
                    .ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(3));
 }
 
 
 TEST(InterpreterParameter8) {
   HandleAndZoneScope handles;
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(8);
   builder.LoadAccumulatorWithRegister(builder.Parameter(0))
       .BinaryOperation(Token::Value::ADD, builder.Parameter(1), Strength::WEAK)
       .BinaryOperation(Token::Value::ADD, builder.Parameter(2), Strength::WEAK)
       .BinaryOperation(Token::Value::ADD, builder.Parameter(3), Strength::WEAK)
       .BinaryOperation(Token::Value::ADD, builder.Parameter(4), Strength::WEAK)
       .BinaryOperation(Token::Value::ADD, builder.Parameter(5), Strength::WEAK)
       .BinaryOperation(Token::Value::ADD, builder.Parameter(6), Strength::WEAK)
       .BinaryOperation(Token::Value::ADD, builder.Parameter(7), Strength::WEAK)
       .Return();
@@ skipping 16 matching lines @@
       callable(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
           .ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(36));
 }
 
 
 TEST(InterpreterParameter1Assign) {
   HandleAndZoneScope handles;
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadLiteral(Smi::FromInt(5))
       .StoreAccumulatorInRegister(builder.Parameter(0))
       .LoadAccumulatorWithRegister(builder.Parameter(0))
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<Handle<Object>>();
 
@@ skipping 109 matching lines @@
   i::FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
   name = factory->string_table()->LookupString(isolate, name);
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(0);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadLiteral(name)
       .LoadNamedProperty(builder.Parameter(0), vector->GetIndex(slot),
                          i::SLOPPY)
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
   auto callable = tester.GetCallable<Handle<Object>>();
 
@@ skipping 36 matching lines @@
   i::FeedbackVectorSlot slot = feedback_spec.AddKeyedLoadICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Handle<i::String> key = factory->NewStringFromAsciiChecked("key");
   key = factory->string_table()->LookupString(isolate, key);
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(1);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadLiteral(key)
       .LoadKeyedProperty(builder.Parameter(0), vector->GetIndex(slot),
                          i::STRICT)
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
   auto callable = tester.GetCallable<Handle<Object>>();
 
@@ skipping 24 matching lines @@
   i::FeedbackVectorSlot slot = feedback_spec.AddStoreICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
   name = factory->string_table()->LookupString(isolate, name);
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(1);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadLiteral(name)
       .StoreAccumulatorInRegister(Register(0))
       .LoadLiteral(Smi::FromInt(999))
       .StoreNamedProperty(builder.Parameter(0), Register(0),
                           vector->GetIndex(slot), i::STRICT)
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(isolate, bytecode_array, vector);
@@ skipping 42 matching lines @@
   i::FeedbackVectorSlot slot = feedback_spec.AddKeyedStoreICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(isolate, &feedback_spec);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
   name = factory->string_table()->LookupString(isolate, name);
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(1);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadLiteral(name)
       .StoreAccumulatorInRegister(Register(0))
       .LoadLiteral(Smi::FromInt(999))
       .StoreKeyedProperty(builder.Parameter(0), Register(0),
                           vector->GetIndex(slot), i::SLOPPY)
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(isolate, bytecode_array, vector);
@@ skipping 32 matching lines @@
       i::NewTypeFeedbackVector(isolate, &feedback_spec);
   int slot_index = vector->GetIndex(slot);
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("func");
   name = factory->string_table()->LookupString(isolate, name);
 
   // Check with no args.
   {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(1);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     builder.LoadLiteral(name)
         .LoadNamedProperty(builder.Parameter(0), slot_index, i::SLOPPY)
         .StoreAccumulatorInRegister(Register(0))
         .Call(Register(0), builder.Parameter(0), 0)
         .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
     auto callable = tester.GetCallable<Handle<Object>>();
 
     Handle<Object> object = InterpreterTester::NewObject(
         "new (function Obj() { this.func = function() { return 0x265; }})()");
     Handle<Object> return_val = callable(object).ToHandleChecked();
     CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(0x265));
   }
 
   // Check that receiver is passed properly.
   {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(1);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     builder.LoadLiteral(name)
         .LoadNamedProperty(builder.Parameter(0), slot_index, i::SLOPPY)
         .StoreAccumulatorInRegister(Register(0))
         .Call(Register(0), builder.Parameter(0), 0)
         .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
     auto callable = tester.GetCallable<Handle<Object>>();
 
     Handle<Object> object = InterpreterTester::NewObject(
         "new (function Obj() {"
         "  this.val = 1234;"
         "  this.func = function() { return this.val; };"
         "})()");
     Handle<Object> return_val = callable(object).ToHandleChecked();
     CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(1234));
   }
 
   // Check with two parameters (+ receiver).
   {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(4);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     builder.LoadLiteral(name)
         .LoadNamedProperty(builder.Parameter(0), slot_index, i::SLOPPY)
         .StoreAccumulatorInRegister(Register(0))
         .LoadAccumulatorWithRegister(builder.Parameter(0))
         .StoreAccumulatorInRegister(Register(1))
         .LoadLiteral(Smi::FromInt(51))
         .StoreAccumulatorInRegister(Register(2))
         .LoadLiteral(Smi::FromInt(11))
         .StoreAccumulatorInRegister(Register(3))
         .Call(Register(0), Register(1), 2)
         .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
     auto callable = tester.GetCallable<Handle<Object>>();
 
     Handle<Object> object = InterpreterTester::NewObject(
         "new (function Obj() { "
         "  this.func = function(a, b) { return a - b; }"
         "})()");
     Handle<Object> return_val = callable(object).ToHandleChecked();
     CHECK(return_val->SameValue(Smi::FromInt(40)));
   }
 
   // Check with 10 parameters (+ receiver).
   {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     builder.set_locals_count(12);
+    builder.set_context_count(0);
     builder.set_parameter_count(1);
     builder.LoadLiteral(name)
         .LoadNamedProperty(builder.Parameter(0), slot_index, i::SLOPPY)
         .StoreAccumulatorInRegister(Register(0))
         .LoadAccumulatorWithRegister(builder.Parameter(0))
         .StoreAccumulatorInRegister(Register(1))
         .LoadLiteral(factory->NewStringFromAsciiChecked("a"))
         .StoreAccumulatorInRegister(Register(2))
         .LoadLiteral(factory->NewStringFromAsciiChecked("b"))
         .StoreAccumulatorInRegister(Register(3))
@@ skipping 53 matching lines @@
       .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK)
       .StoreAccumulatorInRegister(reg)
       .LoadAccumulatorWithRegister(scratch);
 }
 
 
 TEST(InterpreterJumps) {
   HandleAndZoneScope handles;
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(2);
+  builder.set_context_count(0);
   builder.set_parameter_count(0);
   Register reg(0), scratch(1);
   BytecodeLabel label[3];
 
   builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .Jump(&label[1]);
   SetRegister(builder, reg, 1024, scratch).Bind(&label[0]);
   IncrementRegister(builder, reg, 1, scratch).Jump(&label[2]);
   SetRegister(builder, reg, 2048, scratch).Bind(&label[1]);
   IncrementRegister(builder, reg, 2, scratch).Jump(&label[0]);
   SetRegister(builder, reg, 4096, scratch).Bind(&label[2]);
   IncrementRegister(builder, reg, 4, scratch)
       .LoadAccumulatorWithRegister(reg)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 
 TEST(InterpreterConditionalJumps) {
   HandleAndZoneScope handles;
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(2);
+  builder.set_context_count(0);
   builder.set_parameter_count(0);
   Register reg(0), scratch(1);
   BytecodeLabel label[2];
   BytecodeLabel done, done1;
 
   builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .JumpIfFalse(&label[0]);
   IncrementRegister(builder, reg, 1024, scratch)
@@ skipping 68 matching lines @@
 
   for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
     Token::Value comparison = kComparisonTypes[c];
     for (size_t i = 0; i < arraysize(inputs); i++) {
       for (size_t j = 0; j < arraysize(inputs); j++) {
         HandleAndZoneScope handles;
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone());
         Register r0(0);
         builder.set_locals_count(1);
+        builder.set_context_count(0);
         builder.set_parameter_count(0);
         builder.LoadLiteral(Smi::FromInt(inputs[i]))
             .StoreAccumulatorInRegister(r0)
             .LoadLiteral(Smi::FromInt(inputs[j]))
             .CompareOperation(comparison, r0, Strength::WEAK)
             .Return();
 
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
         InterpreterTester tester(handles.main_isolate(), bytecode_array);
         auto callable = tester.GetCallable<>();
@@ skipping 18 matching lines @@
   for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
     Token::Value comparison = kComparisonTypes[c];
     for (size_t i = 0; i < arraysize(inputs); i++) {
       for (size_t j = 0; j < arraysize(inputs); j++) {
         HandleAndZoneScope handles;
         i::Factory* factory = handles.main_isolate()->factory();
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone());
         Register r0(0);
         builder.set_locals_count(1);
+        builder.set_context_count(0);
         builder.set_parameter_count(0);
         builder.LoadLiteral(factory->NewHeapNumber(inputs[i]))
             .StoreAccumulatorInRegister(r0)
             .LoadLiteral(factory->NewHeapNumber(inputs[j]))
             .CompareOperation(comparison, r0, Strength::WEAK)
             .Return();
 
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
         InterpreterTester tester(handles.main_isolate(), bytecode_array);
         auto callable = tester.GetCallable<>();
@@ skipping 15 matching lines @@
     for (size_t i = 0; i < arraysize(inputs); i++) {
       for (size_t j = 0; j < arraysize(inputs); j++) {
         const char* lhs = inputs[i].c_str();
         const char* rhs = inputs[j].c_str();
         HandleAndZoneScope handles;
         i::Factory* factory = handles.main_isolate()->factory();
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone());
         Register r0(0);
         builder.set_locals_count(1);
+        builder.set_context_count(0);
         builder.set_parameter_count(0);
         builder.LoadLiteral(factory->NewStringFromAsciiChecked(lhs))
             .StoreAccumulatorInRegister(r0)
             .LoadLiteral(factory->NewStringFromAsciiChecked(rhs))
             .CompareOperation(comparison, r0, Strength::WEAK)
             .Return();
 
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
         InterpreterTester tester(handles.main_isolate(), bytecode_array);
         auto callable = tester.GetCallable<>();
@@ skipping 26 matching lines @@
           double lhs = StringToDouble(&unicode_cache, lhs_cstr,
                                       i::ConversionFlags::NO_FLAGS);
           double rhs = StringToDouble(&unicode_cache, rhs_cstr,
                                       i::ConversionFlags::NO_FLAGS);
           HandleAndZoneScope handles;
           i::Factory* factory = handles.main_isolate()->factory();
           BytecodeArrayBuilder builder(handles.main_isolate(),
                                        handles.main_zone());
           Register r0(0);
           builder.set_locals_count(1);
+          builder.set_context_count(0);
           builder.set_parameter_count(0);
           if (pass == 0) {
             // Comparison with HeapNumber on the lhs and String on the rhs
             builder.LoadLiteral(factory->NewNumber(lhs))
                 .StoreAccumulatorInRegister(r0)
                 .LoadLiteral(factory->NewStringFromAsciiChecked(rhs_cstr))
                 .CompareOperation(comparison, r0, Strength::WEAK)
                 .Return();
           } else {
             // Comparison with HeapNumber on the rhs and String on the lhs
@@ skipping 24 matching lines @@
   Handle<i::String> name = factory->NewStringFromAsciiChecked("cons");
   Handle<i::JSFunction> func = factory->NewFunction(name);
   Handle<i::JSObject> instance = factory->NewJSObject(func);
   Handle<i::Object> other = factory->NewNumber(3.3333);
   Handle<i::Object> cases[] = {Handle<i::Object>::cast(instance), other};
   for (size_t i = 0; i < arraysize(cases); i++) {
     bool expected_value = (i == 0);
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     Register r0(0);
     builder.set_locals_count(1);
+    builder.set_context_count(0);
     builder.set_parameter_count(0);
     builder.LoadLiteral(cases[i]);
     builder.StoreAccumulatorInRegister(r0)
         .LoadLiteral(func)
         .CompareOperation(Token::Value::INSTANCEOF, r0, Strength::WEAK)
         .Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
@@ skipping 10 matching lines @@
   // Allocate an array
   Handle<i::JSArray> array =
       factory->NewJSArray(i::ElementsKind::FAST_SMI_ELEMENTS);
   // Check for these properties on the array object
   const char* properties[] = {"length", "fuzzle", "x", "0"};
   for (size_t i = 0; i < arraysize(properties); i++) {
     bool expected_value = (i == 0);
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     Register r0(0);
     builder.set_locals_count(1);
+    builder.set_context_count(0);
     builder.set_parameter_count(0);
     builder.LoadLiteral(factory->NewStringFromAsciiChecked(properties[i]))
         .StoreAccumulatorInRegister(r0)
         .LoadLiteral(Handle<Object>::cast(array))
         .CompareOperation(Token::Value::IN, r0, Strength::WEAK)
         .Return();
 
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->IsBoolean());
     CHECK_EQ(return_value->BooleanValue(), expected_value);
   }
 }
 
 
 TEST(InterpreterUnaryNot) {
   HandleAndZoneScope handles;
   for (size_t i = 1; i < 10; i++) {
     bool expected_value = ((i & 1) == 1);
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     Register r0(0);
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(0);
     builder.EnterBlock();
     builder.LoadFalse();
     for (size_t j = 0; j < i; j++) {
       builder.LogicalNot();
     }
     builder.LeaveBlock().Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
@@ skipping 43 matching lines @@
           Handle<Object>::cast(factory->NewStringFromStaticChars("hello")),
           true),
       std::make_pair(
           Handle<Object>::cast(factory->NewStringFromStaticChars("")), false),
   };
 
   for (size_t i = 0; i < arraysize(object_type_tuples); i++) {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     Register r0(0);
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(0);
     builder.EnterBlock();
     LoadAny(&builder, factory, object_type_tuples[i].first);
     builder.CastAccumulatorToBoolean();
     builder.LeaveBlock().Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->IsBoolean());
@@ skipping 17 matching lines @@
           Handle<Object>::cast(factory->NewStringFromStaticChars("hello")),
           false),
       std::make_pair(
           Handle<Object>::cast(factory->NewStringFromStaticChars("")), true),
   };
 
   for (size_t i = 0; i < arraysize(object_type_tuples); i++) {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     Register r0(0);
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(0);
     builder.EnterBlock();
     LoadAny(&builder, factory, object_type_tuples[i].first);
     builder.LogicalNot();
     builder.LeaveBlock().Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->IsBoolean());
@@ skipping 15 matching lines @@
       std::make_pair(factory->NewNumberFromInt(7771), "number"),
       std::make_pair(
           Handle<Object>::cast(factory->NewStringFromStaticChars("hello")),
           "string"),
   };
 
   for (size_t i = 0; i < arraysize(object_type_tuples); i++) {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
     Register r0(0);
     builder.set_locals_count(0);
+    builder.set_context_count(0);
     builder.set_parameter_count(0);
     builder.EnterBlock();
     LoadAny(&builder, factory, object_type_tuples[i].first);
     builder.TypeOf();
     builder.LeaveBlock().Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<v8::internal::String> return_value =
         Handle<v8::internal::String>::cast(callable().ToHandleChecked());
     auto actual = return_value->ToCString();
     CHECK_EQ(strcmp(&actual[0], object_type_tuples[i].second), 0);
   }
 }
 
 
 TEST(InterpreterCallRuntime) {
   HandleAndZoneScope handles;
 
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
   builder.set_locals_count(2);
+  builder.set_context_count(0);
   builder.set_parameter_count(1);
   builder.LoadLiteral(Smi::FromInt(15))
       .StoreAccumulatorInRegister(Register(0))
       .LoadLiteral(Smi::FromInt(40))
       .StoreAccumulatorInRegister(Register(1))
       .CallRuntime(Runtime::kAdd, Register(0), 2)
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
@@ skipping 98 matching lines @@
     std::string source(InterpreterTester::SourceForBody(literals[i].first));
     InterpreterTester tester(handles.main_isolate(), source.c_str());
     auto callable = tester.GetCallable<>();
 
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*literals[i].second));
   }
 }
 
 
+TEST(InterpreterContextVariables) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+
+  std::pair<const char*, Handle<Object>> context_vars[5] = {
+      std::make_pair("var a; (function() { a = 1; })(); return a;",
+                     Handle<Object>(Smi::FromInt(1), isolate)),
+      std::make_pair("var a = 10; (function() { a; })(); return a;",
+                     Handle<Object>(Smi::FromInt(10), isolate)),
+      std::make_pair("var a = 20; var b = 30;\n"
+                     "return (function() { return a + b; })();",
+                     Handle<Object>(Smi::FromInt(50), isolate)),
+      std::make_pair("'use strict'; let a = 1;\n"
+                     "{ let b = 2; return (function() { return a + b; })(); }",
+                     Handle<Object>(Smi::FromInt(3), isolate)),
+      std::make_pair("'use strict'; let a = 10;\n"
+                     "{ let b = 20; var c = function() { [a, b] };\n"
+                     "  return a + b; }",
+                     Handle<Object>(Smi::FromInt(30), isolate)),
+  };
+
+  for (size_t i = 0; i < arraysize(context_vars); i++) {
+    std::string source(InterpreterTester::SourceForBody(context_vars[i].first));
+    InterpreterTester tester(handles.main_isolate(), source.c_str());
+    auto callable = tester.GetCallable<>();
+
+    Handle<i::Object> return_value = callable().ToHandleChecked();
+    CHECK(return_value->SameValue(*context_vars[i].second));
+  }
+}
+
+
+TEST(InterpreterContextParameters) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+
+  std::pair<const char*, Handle<Object>> context_params[3] = {
+      std::make_pair("return (function() { return arg1; })();",
+                     Handle<Object>(Smi::FromInt(1), isolate)),
+      std::make_pair("(function() { arg1 = 4; })(); return arg1;",
+                     Handle<Object>(Smi::FromInt(4), isolate)),
+      std::make_pair("(function() { arg3 = arg2 - arg1; })(); return arg3;",
+                     Handle<Object>(Smi::FromInt(1), isolate)),
+  };
+
+  for (size_t i = 0; i < arraysize(context_params); i++) {
+    std::string source = "function " + InterpreterTester::function_name() +
+                         "(arg1, arg2, arg3) {" + context_params[i].first + "}";
+    InterpreterTester tester(handles.main_isolate(), source.c_str());
+    auto callable =
+        tester.GetCallable<Handle<Object>, Handle<Object>, Handle<Object>>();
+
+    Handle<Object> a1 = Handle<Object>(Smi::FromInt(1), isolate);
+    Handle<Object> a2 = Handle<Object>(Smi::FromInt(2), isolate);
+    Handle<Object> a3 = Handle<Object>(Smi::FromInt(3), isolate);
+    Handle<i::Object> return_value = callable(a1, a2, a3).ToHandleChecked();
+    CHECK(return_value->SameValue(*context_params[i].second));
+  }
+}
+
+
 TEST(InterpreterComma) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
   std::pair<const char*, Handle<Object>> literals[6] = {
       std::make_pair("var a; return 0, a;\n", factory->undefined_value()),
       std::make_pair("return 'a', 2.2, 3;\n",
                      Handle<Object>(Smi::FromInt(3), isolate)),
       std::make_pair("return 'a', 'b', 'c';\n",
@@ skipping 92 matching lines @@
 
   // TODO(rmcilroy): modify tests when we have real try finally support.
   std::string source(InterpreterTester::SourceForBody(
       "var a = 1; try { a = a + 1; } finally { a = a + 2; }; return a;"));
   InterpreterTester tester(handles.main_isolate(), source.c_str());
   auto callable = tester.GetCallable<>();
 
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(4));
 }