[Interpreter] Add support for global loads / stores / calls to BytecodeGraphBuilder.

test/unittests/compiler/bytecode-graph-builder-unittest.cc

Index: test/unittests/compiler/bytecode-graph-builder-unittest.cc
diff --git a/test/unittests/compiler/bytecode-graph-builder-unittest.cc b/test/unittests/compiler/bytecode-graph-builder-unittest.cc
index 8267599b86e273f09b9b47d13836e537f91ee89a..d37a7e72408c4105a30988bee7eb629e3e50fae6 100644
--- a/test/unittests/compiler/bytecode-graph-builder-unittest.cc
+++ b/test/unittests/compiler/bytecode-graph-builder-unittest.cc
@@ -56,6 +56,8 @@ namespace compiler {
   REPEAT_4(SEP, __VA_ARGS__) SEP() REPEAT_2(SEP, __VA_ARGS__) SEP() __VA_ARGS__
 
 
+LanguageMode kLanguageModes[] = {LanguageMode::SLOPPY, LanguageMode::STRICT};
+
 Handle<TypeFeedbackVector> NewTypeFeedbackVector(
     Isolate* isolate, FeedbackVectorSpec* spec) {
   Handle<TypeFeedbackMetadata> vector_metadata =
@@ -70,7 +72,8 @@ class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
 
   Graph* GetCompletedGraph(Handle<BytecodeArray> bytecode_array,
                            MaybeHandle<TypeFeedbackVector> feedback_vector =
-                               MaybeHandle<TypeFeedbackVector>());
+                               MaybeHandle<TypeFeedbackVector>(),
+                           LanguageMode language_mode = LanguageMode::SLOPPY);
 
   Matcher<Node*> IsUndefinedConstant();
   Matcher<Node*> IsNullConstant();
@@ -92,7 +95,8 @@ class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
 
 Graph* BytecodeGraphBuilderTest::GetCompletedGraph(
     Handle<BytecodeArray> bytecode_array,
-    MaybeHandle<TypeFeedbackVector> feedback_vector) {
+    MaybeHandle<TypeFeedbackVector> feedback_vector,
+    LanguageMode language_mode) {
   MachineOperatorBuilder* machine = new (zone()) MachineOperatorBuilder(
       zone(), kMachPtr, InstructionSelector::SupportedMachineOperatorFlags());
   CommonOperatorBuilder* common = new (zone()) CommonOperatorBuilder(zone());
@@ -111,6 +115,7 @@ Graph* BytecodeGraphBuilderTest::GetCompletedGraph(
   }
 
   ParseInfo parse_info(zone(), shared_info);
+  parse_info.set_language_mode(language_mode);
   CompilationInfo info(&parse_info);
   info.shared_info()->set_function_data(*bytecode_array);
 
@@ -507,6 +512,93 @@ TEST_F(BytecodeGraphBuilderTest, CallProperty2) {
   EXPECT_THAT(ret, IsReturn(call_matcher, _, _));
 }
 
+
+TEST_F(BytecodeGraphBuilderTest, LoadGlobal) {
+  const TypeofMode kTypeOfModes[] = {TypeofMode::NOT_INSIDE_TYPEOF,
+                                     TypeofMode::INSIDE_TYPEOF};
+  const bool kWideBytecode[] = {false, true};
+  TRACED_FOREACH(LanguageMode, language_mode, kLanguageModes) {
+    TRACED_FOREACH(TypeofMode, typeof_mode, kTypeOfModes) {
+      TRACED_FOREACH(bool, wide_bytecode, kWideBytecode) {
+        FeedbackVectorSpec feedback_spec(zone());
+        if (wide_bytecode) {
+          for (int i = 0; i < 128; i++) {
+            feedback_spec.AddLoadICSlot();
+          }
+        }
+        FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
+        Handle<TypeFeedbackVector> vector =
+            NewTypeFeedbackVector(isolate(), &feedback_spec);
+
+        interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
+        array_builder.set_locals_count(0);
+        array_builder.set_context_count(0);
+        array_builder.set_parameter_count(1);
+
+        Handle<Name> name = GetName(isolate(), "global");
+        size_t name_index = array_builder.GetConstantPoolEntry(name);
+
+        array_builder.LoadGlobal(name_index, vector->GetIndex(slot),
+                                 language_mode, typeof_mode)
+            .Return();
+        Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray(),
+                                         vector, language_mode);
+
+        Node* ret = graph->end()->InputAt(0);
+        Node* start = graph->start();
+
+        Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
+        Matcher<Node*> load_global_matcher = IsJSLoadGlobal(
+            name, typeof_mode, feedback_vector_matcher, start, start);
+
+        EXPECT_THAT(ret, IsReturn(load_global_matcher, _, _));
+      }
+    }
+  }
+}
+
+
+TEST_F(BytecodeGraphBuilderTest, StoreGlobal) {
+  const bool kWideBytecode[] = {false, true};
+  TRACED_FOREACH(LanguageMode, language_mode, kLanguageModes) {
+    TRACED_FOREACH(bool, wide_bytecode, kWideBytecode) {
+      FeedbackVectorSpec feedback_spec(zone());
+      if (wide_bytecode) {
+        for (int i = 0; i < 128; i++) {
+          feedback_spec.AddStoreICSlot();
+        }
+      }
+      FeedbackVectorSlot slot = feedback_spec.AddStoreICSlot();
+      Handle<TypeFeedbackVector> vector =
+          NewTypeFeedbackVector(isolate(), &feedback_spec);
+
+      interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
+      array_builder.set_locals_count(0);
+      array_builder.set_context_count(0);
+      array_builder.set_parameter_count(1);
+
+      Handle<Name> name = GetName(isolate(), "global");
+      size_t name_index = array_builder.GetConstantPoolEntry(name);
+
+      array_builder.LoadLiteral(Smi::FromInt(321))
+          .StoreGlobal(name_index, vector->GetIndex(slot), language_mode)
+          .Return();
+      Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray(), vector,
+                                       language_mode);
+
+      Node* ret = graph->end()->InputAt(0);
+      Node* start = graph->start();
+
+      Matcher<Node*> value_matcher = IsNumberConstant(321);
+      Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
+      Matcher<Node*> store_global_matcher = IsJSStoreGlobal(
+          name, value_matcher, feedback_vector_matcher, start, start);
+
+      EXPECT_THAT(ret, IsReturn(_, store_global_matcher, _));
+    }
+  }
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8