[Interpreter] Adds implementation of bytecode graph builder for LoadICSloppy/Strict

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"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
+#include "src/compiler/linkage.h"
 #include "src/interpreter/bytecode-array-builder.h"
+#include "src/interpreter/interpreter.h"
 #include "src/parser.h"
 #include "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/compiler/graph-unittest.h"
 #include "test/unittests/compiler/node-test-utils.h"
 #include "test/unittests/test-utils.h"
 
 using ::testing::_;
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+#define SPACE()
+
+#define REPEAT_2(SEP, ...) __VA_ARGS__ SEP() __VA_ARGS__
+#define REPEAT_4(SEP, ...) \
+  REPEAT_2(SEP, __VA_ARGS__) SEP() REPEAT_2(SEP, __VA_ARGS__)
+#define REPEAT_8(SEP, ...) \
+  REPEAT_4(SEP, __VA_ARGS__) SEP() REPEAT_4(SEP, __VA_ARGS__)
+#define REPEAT_16(SEP, ...) \
+  REPEAT_8(SEP, __VA_ARGS__) SEP() REPEAT_8(SEP, __VA_ARGS__)
+#define REPEAT_32(SEP, ...) \
+  REPEAT_16(SEP, __VA_ARGS__) SEP() REPEAT_16(SEP, __VA_ARGS__)
+#define REPEAT_64(SEP, ...) \
+  REPEAT_32(SEP, __VA_ARGS__) SEP() REPEAT_32(SEP, __VA_ARGS__)
+#define REPEAT_128(SEP, ...) \
+  REPEAT_64(SEP, __VA_ARGS__) SEP() REPEAT_64(SEP, __VA_ARGS__)
+#define REPEAT_256(SEP, ...) \
+  REPEAT_128(SEP, __VA_ARGS__) SEP() REPEAT_128(SEP, __VA_ARGS__)
+
+#define REPEAT_127(SEP, ...)  \
+  REPEAT_64(SEP, __VA_ARGS__) \
+  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";
+
+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) {}
+
+  Graph* GetCompletedGraph() {
+    ParseInfo parse_info(zone_);
+    if (script_) {
+      v8::Context::New(v8::Isolate::GetCurrent())->Enter();
+      v8::Local<v8::Context> context =
+          v8::Isolate::GetCurrent()->GetCurrentContext();
+      CompileRun(script_);
+
+      Local<Function> api_function =
+          Local<Function>::Cast(context->Global()
+                                    ->Get(context, v8_str(kFunctionName))
+                                    .ToLocalChecked());
+      Handle<JSFunction> function =
+          Handle<JSFunction>::cast(v8::Utils::OpenHandle(*api_function));
+      CHECK(function->shared()->HasBytecodeArray());
+
+      context->Exit();
+      ParseInfo p(zone_, function);

[rmcilroy, 2015/11/11 14:10:06]

don't use single letter variable names - also, no need for the extra variable,
just do:
parse_info = ParseInfo(zone_, shared_info);

[mythria, 2015/11/11 15:32:50]

Done.

+      parse_info = p;
+    } else {
+      DCHECK(!bytecode_.is_null());
+      Handle<String> name =
+          isolate_->factory()->NewStringFromAsciiChecked(kFunctionName);
+      std::string script_str("function " + std::string(kFunctionName) +
+                             "() {}");
+      Handle<String> script =
+          isolate_->factory()->NewStringFromAsciiChecked(script_str.c_str());
+      Handle<SharedFunctionInfo> shared_info =
+          isolate_->factory()->NewSharedFunctionInfo(name, MaybeHandle<Code>());
+      shared_info->set_script(*isolate_->factory()->NewScript(script));
+      ParseInfo p(zone_, shared_info);

[rmcilroy, 2015/11/11 14:10:06]

ditto

[mythria, 2015/11/11 15:32:50]

Done.

+      parse_info = p;
+    }
+
+    CompilationInfo info(&parse_info);
+    if (!bytecode_.is_null()) {
+      info.shared_info()->set_function_data(*bytecode_.ToHandleChecked());
+    }
+
+    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);
+
+    BytecodeGraphBuilder graph_builder(zone_, &info, jsgraph);
+    graph_builder.CreateGraph();
+    return graph;
+  }
+
+  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:
+  GraphGeneratorHelper(Isolate* isolate, Zone* zone, const char* script,
+                       MaybeHandle<BytecodeArray> bytecode)
+      : isolate_(isolate), zone_(zone), script_(script), bytecode_(bytecode) {
+    i::FLAG_ignition = true;
+    i::FLAG_always_opt = false;
+    i::FLAG_vector_stores = true;
+    // Set ignition filter flag via SetFlagsFromString to avoid double-free
+    // (or potential leak with StrDup() based on ownership confusion).
+    ScopedVector<char> ignition_filter(64);
+    SNPrintF(ignition_filter, "--ignition-filter=%s", kFunctionName);
+    FlagList::SetFlagsFromString(ignition_filter.start(),
+                                 ignition_filter.length());
+    // Ensure handler table is generated.
+    isolate_->interpreter()->Initialize();
+  }
+
+  static v8::Local<v8::String> v8_str(const char* string) {
+    v8::Local<v8::String> v8_string =
+        v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), string,
+                                v8::NewStringType::kNormal)
+            .ToLocalChecked();
+    return v8_string;
+  }
+
+  static Local<Value> CompileRun(const char* source) {
+    v8::Local<v8::Context> context =
+        v8::Isolate::GetCurrent()->GetCurrentContext();
+    v8::Local<v8::Script> compiled_script =
+        (v8::Script::Compile(context, v8_str(source)).ToLocalChecked());
+    return compiled_script->Run(context).ToLocalChecked();
+  }
+
+  Isolate* isolate_;
+  Zone* zone_;
+  const char* script_;
+  MaybeHandle<BytecodeArray> bytecode_;
+};
+
+
 class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
  public:
   BytecodeGraphBuilderTest() : array_builder_(isolate(), zone()) {}
 
-  Graph* GetCompletedGraph();
-
   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);
 
   interpreter::BytecodeArrayBuilder* array_builder() { return &array_builder_; }
 
  private:
   interpreter::BytecodeArrayBuilder array_builder_;
 
   DISALLOW_COPY_AND_ASSIGN(BytecodeGraphBuilderTest);
 };
 
 
-Graph* BytecodeGraphBuilderTest::GetCompletedGraph() {
-  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));
-
-  ParseInfo parse_info(zone(), shared_info);
-  CompilationInfo info(&parse_info);
-  Handle<BytecodeArray> bytecode_array = array_builder()->ToBytecodeArray();
-  info.shared_info()->set_function_data(*bytecode_array);
-
-  BytecodeGraphBuilder graph_builder(zone(), &info, jsgraph);
-  graph_builder.CreateGraph();
-  return graph;
-}
-
-
 Matcher<Node*> BytecodeGraphBuilderTest::IsUndefinedConstant() {
   return IsHeapConstant(factory()->undefined_value());
 }
 
 
 Matcher<Node*> BytecodeGraphBuilderTest::IsNullConstant() {
   return IsHeapConstant(factory()->null_value());
 }
 
 
 Matcher<Node*> BytecodeGraphBuilderTest::IsTheHoleConstant() {
   return IsHeapConstant(factory()->the_hole_value());
 }
 
 
 Matcher<Node*> BytecodeGraphBuilderTest::IsFalseConstant() {
   return IsHeapConstant(factory()->false_value());
 }
 
 
 Matcher<Node*> BytecodeGraphBuilderTest::IsTrueConstant() {
   return IsHeapConstant(factory()->true_value());
 }
 
 
+Matcher<Node*> BytecodeGraphBuilderTest::IsIntPtrConstant(int value) {
+  if (kPointerSize == 8) {
+    return IsInt64Constant(value);
+  } else {
+    return IsInt32Constant(value);
+  }
+}
+
+
+Matcher<Node*> BytecodeGraphBuilderTest::IsFeedbackVector(Node* effect,
+                                                          Node* control) {
+  int offset = SharedFunctionInfo::kFeedbackVectorOffset - kHeapObjectTag;
+  int offset1 = JSFunction::kSharedFunctionInfoOffset - kHeapObjectTag;
+
+  return IsLoad(kMachAnyTagged,
+                IsLoad(kMachAnyTagged,
+                       IsParameter(Linkage::kJSFunctionCallClosureParamIndex),
+                       IsIntPtrConstant(offset1), effect, control),
+                IsIntPtrConstant(offset), effect, control);
+}
+
+
 TEST_F(BytecodeGraphBuilderTest, ReturnUndefined) {
   array_builder()->set_locals_count(0);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadUndefined().Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsUndefinedConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnNull) {
   array_builder()->set_locals_count(0);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadNull().Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   EXPECT_THAT(ret, IsReturn(IsNullConstant(), graph->start(), graph->start()));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnTheHole) {
   array_builder()->set_locals_count(0);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadTheHole().Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsTheHoleConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnTrue) {
   array_builder()->set_locals_count(0);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadTrue().Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsTrueConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnFalse) {
   array_builder()->set_locals_count(0);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadFalse().Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsFalseConstant(), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnInt8) {
   static const int kValue = 3;
   array_builder()->set_locals_count(0);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadLiteral(Smi::FromInt(kValue)).Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsNumberConstant(kValue), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, ReturnDouble) {
   const double kValue = 0.123456789;
   array_builder()->set_locals_count(0);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()->LoadLiteral(factory()->NewHeapNumber(kValue));
   array_builder()->Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   Node* effect = graph->start();
   Node* control = graph->start();
   EXPECT_THAT(ret, IsReturn(IsNumberConstant(kValue), effect, control));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, SimpleExpressionWithParameters) {
   array_builder()->set_locals_count(1);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(3);
   array_builder()
       ->LoadAccumulatorWithRegister(array_builder()->Parameter(1))
       .BinaryOperation(Token::Value::ADD, array_builder()->Parameter(2),
                        Strength::WEAK)
       .StoreAccumulatorInRegister(interpreter::Register(0))
       .Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  Graph* graph = helper.GetCompletedGraph();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   // NB binary operation is <reg> <op> <acc>. The register represents
   // the left-hand side, which is why parameters appear in opposite
   // order to construction via the builder.
   EXPECT_THAT(ret, IsReturn(IsJSAdd(IsParameter(2), IsParameter(1)), _, _));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, SimpleExpressionWithRegister) {
   static const int kLeft = -655371;
   static const int kRight = +2000000;
   array_builder()->set_locals_count(1);
   array_builder()->set_context_count(0);
   array_builder()->set_parameter_count(1);
   array_builder()
       ->LoadLiteral(Smi::FromInt(kLeft))
       .StoreAccumulatorInRegister(interpreter::Register(0))
       .LoadLiteral(Smi::FromInt(kRight))
       .BinaryOperation(Token::Value::ADD, interpreter::Register(0),
                        Strength::WEAK)
       .Return();
 
-  Graph* graph = GetCompletedGraph();
+  GraphGeneratorHelper helper(isolate(), zone(),
+                              array_builder()->ToBytecodeArray());
+  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();
+
+  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);
+
+  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();
+
+  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);
+
+  EXPECT_THAT(ret, IsReturn(load_named_matcher, _, _));
+}
+
+
+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, _, _));
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8