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

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 38 matching lines @@
   SEP()                       \
   REPEAT_32(SEP, __VA_ARGS__) \
   SEP()                       \
   REPEAT_16(SEP, __VA_ARGS__) \
   SEP()                       \
   REPEAT_8(SEP, __VA_ARGS__)  \
   SEP()                       \
   REPEAT_4(SEP, __VA_ARGS__) SEP() REPEAT_2(SEP, __VA_ARGS__) SEP() __VA_ARGS__
 
 static const char* kFunctionName = "f";
+static const char* kLanguageModeStatements[] = {"", " 'use strict'; "};
 
 class GraphGeneratorHelper {
  public:
   GraphGeneratorHelper(Isolate* isolate, Zone* zone, const char* script)
       : GraphGeneratorHelper(isolate, zone, script,
                              MaybeHandle<BytecodeArray>()) {}
 
   GraphGeneratorHelper(Isolate* isolate, Zone* zone,
                        MaybeHandle<BytecodeArray> bytecode)
       : GraphGeneratorHelper(isolate, zone, nullptr, bytecode) {}
@@ skipping 331 matching lines @@
   Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   EXPECT_THAT(
       ret, IsReturn(IsJSAdd(IsNumberConstant(kLeft), IsNumberConstant(kRight)),
                     _, _));
 }
 
 
-TEST_F(BytecodeGraphBuilderTest, NamedLoadSloppy) {
-  const char* code_snippet = "function f(p1) {return p1.val;}; f({val:10});";
-  GraphGeneratorHelper helper(isolate(), zone(), code_snippet);
-  Graph* graph = helper.GetCompletedGraph();
+TEST_F(BytecodeGraphBuilderTest, LoadNamed) {
+  TRACED_FOREACH(const char*, language_mode, kLanguageModeStatements) {
+    std::string code_snippet = std::string("function f(p1) {") + language_mode +
+                               " return p1.val;}; f({val:10});";
+    GraphGeneratorHelper helper(isolate(), zone(), code_snippet.c_str());
+    Graph* graph = helper.GetCompletedGraph();
 
-  Node* ret = graph->end()->InputAt(0);
-  Node* start = graph->start();
+    Node* ret = graph->end()->InputAt(0);
+    Node* start = graph->start();
 
-  Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "val");
-  Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
-  Matcher<Node*> load_named_matcher = IsJSLoadNamed(
-      name, IsParameter(1), feedback_vector_matcher, start, start);
+    Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "val");
+    Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
+    Matcher<Node*> load_named_matcher = IsJSLoadNamed(
+        name, IsParameter(1), feedback_vector_matcher, start, start);
 
-  EXPECT_THAT(ret, IsReturn(load_named_matcher, _, _));
+    EXPECT_THAT(ret, IsReturn(load_named_matcher, _, _));
+  }
 }
 
 
-TEST_F(BytecodeGraphBuilderTest, NamedLoadStrict) {
-  const char* code_snippet =
-      "function f(p1) {'use strict'; return p1.val;}; f({val:10});";
-  GraphGeneratorHelper helper(isolate(), zone(), code_snippet);
-  Graph* graph = helper.GetCompletedGraph();
+TEST_F(BytecodeGraphBuilderTest, LoadNamedWide) {
+  TRACED_FOREACH(const char*, language_mode, kLanguageModeStatements) {
+    std::string code_snippet = std::string("function f(p1) {") + language_mode +
+                               REPEAT_127(SPACE, " var b = p1.val_prev; ")
+                               " return p1.val;}; f({val:10, val_prev:20});";
+    GraphGeneratorHelper helper(isolate(), zone(), code_snippet.c_str());
+    Graph* graph = helper.GetCompletedGraph();
 
-  Node* ret = graph->end()->InputAt(0);
-  Node* start = graph->start();
+    Node* ret = graph->end()->InputAt(0);
+    Node* start = graph->start();
 
-  Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "val");
-  Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
-  Matcher<Node*> load_named_matcher = IsJSLoadNamed(
-      name, IsParameter(1), feedback_vector_matcher, start, start);
+    Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "val");
+    Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
+    Matcher<Node*> preceeding_load = IsJSLoadNamed(
+        GraphGeneratorHelper::GetName(isolate(), "val_prev"), _, _, _, _);
+    Matcher<Node*> load_named_matcher_wide =
+        IsJSLoadNamed(name, IsParameter(1), feedback_vector_matcher,
+                      preceeding_load, IsIfSuccess(_));
 
-  EXPECT_THAT(ret, IsReturn(load_named_matcher, _, _));
+    EXPECT_THAT(ret, IsReturn(load_named_matcher_wide, _, _));
+  }
 }
 
 
-TEST_F(BytecodeGraphBuilderTest, NamedLoadSloppyWide) {
-  const char code_snippet[] = "function f(p1) {var b; "
-                              REPEAT_127(SPACE, " b = p1.val_prev; ")
-                              "return p1.val;}; f({val:10, val_prev:20});";
-  GraphGeneratorHelper helper(isolate(), zone(), code_snippet);
-  Graph* graph = helper.GetCompletedGraph();
-
-  Node* ret = graph->end()->InputAt(0);
-  Node* start = graph->start();
-
-  Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "val");
-  Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
-  Matcher<Node*> preceeding_load = IsJSLoadNamed(
-      GraphGeneratorHelper::GetName(isolate(), "val_prev"), _, _, _, _);
-  Matcher<Node*> load_named_matcher_wide =
-      IsJSLoadNamed(name, IsParameter(1), feedback_vector_matcher,
-                    preceeding_load, IsIfSuccess(_));
-
-  EXPECT_THAT(ret, IsReturn(load_named_matcher_wide, _, _));
-}
-
-
-TEST_F(BytecodeGraphBuilderTest, NamedLoadStrictWide) {
-  const char code_snippet[] = "function f(p1) {'use strict'; var b;"
-                              REPEAT_127(SPACE, " b = p1.val_prev; ")
-                              "return p1.val;}; f({val:10, val_prev:20});";
-  GraphGeneratorHelper helper(isolate(), zone(), code_snippet);
-  Graph* graph = helper.GetCompletedGraph();
-
-  Node* ret = graph->end()->InputAt(0);
-  Node* start = graph->start();
-
-  Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "val");
-  Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
-  Matcher<Node*> preceeding_load = IsJSLoadNamed(
-      GraphGeneratorHelper::GetName(isolate(), "val_prev"), _, _, _, _);
-  Matcher<Node*> load_named_matcher_wide =
-      IsJSLoadNamed(name, IsParameter(1), feedback_vector_matcher,
-                    preceeding_load, IsIfSuccess(_));
-
-  EXPECT_THAT(ret, IsReturn(load_named_matcher_wide, _, _));
-}
-
-
 TEST_F(BytecodeGraphBuilderTest, CallProperty0) {
   const char* code_snippet =
       "function f(p1) {return p1.func();}; f({func(){}});";
   GraphGeneratorHelper helper(isolate(), zone(), code_snippet);
   Graph* graph = helper.GetCompletedGraph();
 
   Node* ret = graph->end()->InputAt(0);
   Node* start = graph->start();
 
   Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "func");
@@ skipping 27 matching lines @@
   call_inputs.push_back(load_named_matcher);
   call_inputs.push_back(IsParameter(1));
   call_inputs.push_back(IsParameter(2));
   call_inputs.push_back(IsParameter(3));
   Matcher<Node*> call_matcher =
       IsJSCallFunction(call_inputs, load_named_matcher, IsIfSuccess(_));
 
   EXPECT_THAT(ret, IsReturn(call_matcher, _, _));
 }
 
+
+TEST_F(BytecodeGraphBuilderTest, LoadGlobal) {
+  TRACED_FOREACH(const char*, language_mode, kLanguageModeStatements) {
+    std::string code_snippet = std::string("var global = 123; function f() {") +
+                               language_mode + " return global; }; f();";
+    GraphGeneratorHelper helper(isolate(), zone(), code_snippet.c_str());
+    Graph* graph = helper.GetCompletedGraph();
+
+    Node* ret = graph->end()->InputAt(0);
+    Node* start = graph->start();
+
+    Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "global");
+    Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
+    Matcher<Node*> load_global_matcher =
+        IsJSLoadGlobal(name, feedback_vector_matcher, start, start);
+
+    EXPECT_THAT(ret, IsReturn(load_global_matcher, _, _));
+  }
+}
+
+
+TEST_F(BytecodeGraphBuilderTest, LoadGlobalWide) {
+  TRACED_FOREACH(const char*, language_mode, kLanguageModeStatements) {
+    std::string code_snippet =
+        std::string("var global = 123; var global_obj = {name:'abc'};") +
+        "function f() {" + language_mode +
+        REPEAT_127(SPACE, " var b = global_obj.name;\n") +
+        " return global;}; f();";
+    GraphGeneratorHelper helper(isolate(), zone(), code_snippet.c_str());
+    Graph* graph = helper.GetCompletedGraph();
+
+    Node* ret = graph->end()->InputAt(0);
+    Node* start = graph->start();
+
+    Handle<Name> global_name =
+        GraphGeneratorHelper::GetName(isolate(), "global");
+    Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
+    Matcher<Node*> preceeding_load = IsJSLoadNamed(
+        GraphGeneratorHelper::GetName(isolate(), "name"), _, _, _, _);
+    Matcher<Node*> load_global_matcher_wide = IsJSLoadGlobal(
+        global_name, feedback_vector_matcher, preceeding_load, IsIfSuccess(_));
+
+    EXPECT_THAT(ret, IsReturn(load_global_matcher_wide, _, _));
+  }
+}
+
+
+TEST_F(BytecodeGraphBuilderTest, StoreGlobal) {
+  TRACED_FOREACH(const char*, language_mode, kLanguageModeStatements) {
+    std::string code_snippet = std::string("var global = 123; function f() {") +
+                               language_mode + " global = 321; }; f();";
+    GraphGeneratorHelper helper(isolate(), zone(), code_snippet.c_str());
+    Graph* graph = helper.GetCompletedGraph();
+
+    Node* ret = graph->end()->InputAt(0);
+    Node* start = graph->start();
+
+    Handle<Name> name = GraphGeneratorHelper::GetName(isolate(), "global");
+    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, _));
+  }
+}
+
+
+TEST_F(BytecodeGraphBuilderTest, StoreGlobalWide) {
+  TRACED_FOREACH(const char*, language_mode, kLanguageModeStatements) {
+    std::string code_snippet =
+        std::string("var global = 123; var global_obj = {name:'abc'};") +
+        "function f() {" + language_mode +
+        REPEAT_127(SPACE, " var b = global_obj.name;\n") +
+        " global = 321;}; f();";
+    GraphGeneratorHelper helper(isolate(), zone(), code_snippet.c_str());
+    Graph* graph = helper.GetCompletedGraph();
+
+    Node* ret = graph->end()->InputAt(0);
+    Node* start = graph->start();
+
+    Handle<Name> global_name =
+        GraphGeneratorHelper::GetName(isolate(), "global");
+    Matcher<Node*> value_matcher = IsNumberConstant(321);
+    Matcher<Node*> feedback_vector_matcher = IsFeedbackVector(start, start);
+    Matcher<Node*> preceeding_load = IsJSLoadNamed(
+        GraphGeneratorHelper::GetName(isolate(), "name"), _, _, _, _);
+    Matcher<Node*> store_global_matcher_wide =
+        IsJSStoreGlobal(global_name, value_matcher, feedback_vector_matcher,
+                        preceeding_load, IsIfSuccess(_));
+
+    EXPECT_THAT(ret, IsReturn(_, store_global_matcher_wide, _));
+  }
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8