[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__
 
 
+LanguageMode kLanguageModes[] = {LanguageMode::SLOPPY, LanguageMode::STRICT};
+
 Handle<TypeFeedbackVector> NewTypeFeedbackVector(
     Isolate* isolate, FeedbackVectorSpec* spec) {
   Handle<TypeFeedbackMetadata> vector_metadata =
       TypeFeedbackMetadata::New(isolate, spec);
   return TypeFeedbackVector::New(isolate, vector_metadata);
 }
 
 
 class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
  public:
   BytecodeGraphBuilderTest() {}
 
   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();
   Matcher<Node*> IsTheHoleConstant();
   Matcher<Node*> IsFalseConstant();
   Matcher<Node*> IsTrueConstant();
   Matcher<Node*> IsIntPtrConstant(int value);
   Matcher<Node*> IsFeedbackVector(Node* effect, Node* control);
 
   static Handle<String> GetName(Isolate* isolate, const char* name) {
     Handle<String> result = isolate->factory()->NewStringFromAsciiChecked(name);
     return isolate->factory()->string_table()->LookupString(isolate, result);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BytecodeGraphBuilderTest);
 };
 
 
 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());
   JSOperatorBuilder* javascript = new (zone()) JSOperatorBuilder(zone());
   Graph* graph = new (zone()) Graph(zone());
   JSGraph* jsgraph = new (zone())
       JSGraph(isolate(), graph, common, javascript, nullptr, machine);
 
   Handle<String> name = factory()->NewStringFromStaticChars("test");
   Handle<String> script = factory()->NewStringFromStaticChars("test() {}");
   Handle<SharedFunctionInfo> shared_info =
       factory()->NewSharedFunctionInfo(name, MaybeHandle<Code>());
   shared_info->set_script(*factory()->NewScript(script));
   if (!feedback_vector.is_null()) {
     shared_info->set_feedback_vector(*feedback_vector.ToHandleChecked());
   }
 
   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);
 
   BytecodeGraphBuilder graph_builder(zone(), &info, jsgraph);
   graph_builder.CreateGraph();
   return graph;
 }
 
 
 Matcher<Node*> BytecodeGraphBuilderTest::IsUndefinedConstant() {
@@ skipping 376 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) {
+  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