[Interpreter] Add support for global declarations and load/store of global variables

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 537 matching lines @@
   Handle<Smi> arg7 = Handle<Smi>(Smi::FromInt(7), handles.main_isolate());
   Handle<Smi> arg8 = Handle<Smi>(Smi::FromInt(8), handles.main_isolate());
   // Check for Smis.
   Handle<Object> return_val =
       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_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>>();
+
+  Handle<Object> return_val =
+      callable(Handle<Smi>(Smi::FromInt(3), handles.main_isolate()))
+          .ToHandleChecked();
+  CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(5));
+}
+
+
 TEST(InterpreterLoadGlobal) {
   HandleAndZoneScope handles;
 
   // Test loading a global.
   std::string source(
       "var global = 321;\n"
       "function " + InterpreterTester::function_name() + "() {\n"
       "  return global;\n"
       "}");
   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(321));
 }
 
 
+TEST(InterpreterStoreGlobal) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Factory* factory = isolate->factory();
+
+  // Test storing to a global.
+  std::string source(
+      "var global = 321;\n"
+      "function " + InterpreterTester::function_name() + "() {\n"
+      "  global = 999;\n"
+      "}");
+  InterpreterTester tester(handles.main_isolate(), source.c_str());
+  auto callable = tester.GetCallable<>();
+
+  callable().ToHandleChecked();
+  Handle<i::String> name = factory->InternalizeUtf8String("global");
+  Handle<i::Object> global_obj =
+      Object::GetProperty(isolate->global_object(), name).ToHandleChecked();
+  CHECK_EQ(Smi::cast(*global_obj), Smi::FromInt(999));
+}
+
+
 TEST(InterpreterCallGlobal) {
   HandleAndZoneScope handles;
 
   // Test calling a global function.
   std::string source(
       "function g_add(a, b) { return a + b; }\n"
       "function " + InterpreterTester::function_name() + "() {\n"
       "  return g_add(5, 10);\n"
       "}");
   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(15));
 }
 
 
+TEST(InterpreterLoadUnallocated) {
+  HandleAndZoneScope handles;
+
+  // Test loading an unallocated global.
+  std::string source(
+      "unallocated = 123;\n"
+      "function " + InterpreterTester::function_name() + "() {\n"
+      "  return unallocated;\n"
+      "}");
+  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(123));
+}
+
+
+TEST(InterpreterStoreUnallocated) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Factory* factory = isolate->factory();
+
+  // Test storing to an unallocated global.
+  std::string source(
+      "unallocated = 321;\n"
+      "function " + InterpreterTester::function_name() + "() {\n"
+      "  unallocated = 999;\n"
+      "}");
+  InterpreterTester tester(handles.main_isolate(), source.c_str());
+  auto callable = tester.GetCallable<>();
+
+  callable().ToHandleChecked();
+  Handle<i::String> name = factory->InternalizeUtf8String("unallocated");
+  Handle<i::Object> global_obj =
+      Object::GetProperty(isolate->global_object(), name).ToHandleChecked();
+  CHECK_EQ(Smi::cast(*global_obj), Smi::FromInt(999));
+}
+
+
 TEST(InterpreterLoadNamedProperty) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
   i::Zone zone;
 
   i::FeedbackVectorSpec feedback_spec(&zone);
   i::FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
@@ skipping 862 matching lines @@
       .CallRuntime(Runtime::kAdd, Register(0), 2)
       .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(55));
 }