[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, ...)  \

[Benedikt Meurer, 2015/11/12 13:45:02]

Do we really need/want these macros here? That looks like we should be able to
get away without them.

[rmcilroy, 2015/11/12 13:48:56]

This is to force the code to emit a Wide bytecode variant

[mythria, 2015/11/13 09:42:56]

With the new changes, they are not required. So removed them.

+  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();
+      parse_info = ParseInfo(zone_, function);
+    } 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));
+      parse_info = ParseInfo(zone_, shared_info);
+    }
+
+    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;

[Michael Starzinger, 2015/11/12 13:40:09]

Ouch! Changing global flags in unit tests is a no-go. We want to be able to
eventually run all of them in a single process. This really should be turned
into a cctest!

[Benedikt Meurer, 2015/11/12 13:45:02]

Don't change the flags in a unittest. This is not going to work as expected. The
idea for unittests is that you can run the binary itself, which means that unit
tests have to be unit tests and must not mutate the global state.

[rmcilroy, 2015/11/12 13:48:56]

Yeah sorry, missed this. I'll move this to be a cctest.

[mythria, 2015/11/13 09:42:56]

Since we use Matcher<Node*>, we retained this in unittest and changed it to
build the bytecode array. 

[Michael Starzinger, 2015/11/13 12:37:08]

Acknowledged. Even better. Awesome!

+    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(),

[Benedikt Meurer, 2015/11/12 13:45:02]

Same here.

[mythria, 2015/11/13 09:42:56]

Done.

+                                 ignition_filter.length());
+    // Ensure handler table is generated.
+    isolate_->interpreter()->Initialize();

[Benedikt Meurer, 2015/11/12 13:45:02]

And here.

[mythria, 2015/11/13 09:42:56]

Done.

+  }
+
+  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(),

[Michael Starzinger, 2015/11/12 13:36:14]

It looks like the GraphGeneratorHelper is used in every unit test in this file.
Is there a particular reason we couldn't just move everything into the
BytecodeGraphBuilderTest class?

+                              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);

[Michael Starzinger, 2015/11/12 13:36:14]

I understand that it is tempting to generate the bytecode from a source string.
But this is no longer a real unit test, because it requires the entire parser to
run. How would you feel about turning these into a cctest eventually (not in
this CL)?

+  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; ")

[Benedikt Meurer, 2015/11/12 13:45:02]

Using strings here is not a good idea, because then your unit tests depend on
the parser (and a lot of other machinery) and are essentially not unit tests,
but system tests.

[mythria, 2015/11/13 09:42:56]

Done.

+                              "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;"

[Benedikt Meurer, 2015/11/12 13:45:02]

Same here.

[mythria, 2015/11/13 09:42:56]

Done.

+                              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