[Interpreter] Adds support for wide variant of load/store lookup slots.

test/cctest/compiler/test-run-bytecode-graph-builder.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 <utility>
 
 #include "src/compiler/pipeline.h"
 #include "src/execution.h"
 #include "src/handles.h"
 #include "src/interpreter/bytecode-array-builder.h"
@@ skipping 1020 matching lines @@
                                   "  var z = 20;"
                                   "  eval(\"function t() {";
   const char* function_epilogue = "        }; f = t; t();\");"
                                   "}"
                                   "f1();";
 
   ExpectedSnippet<0> snippets[] = {
       {"return x;", {factory->NewNumber(12)}},
       {"return obj.val;", {factory->NewNumber(3.1414)}},
       {"return typeof x;", {factory->NewStringFromStaticChars("number")}},
+      {"return typeof dummy;",
+       {factory->NewStringFromStaticChars("undefined")}},
       {"x = 23; return x;", {factory->NewNumber(23)}},
       {"'use strict'; obj.val = 23.456; return obj.val;",
        {factory->NewNumber(23.456)}}};
 
   size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
   for (size_t i = 0; i < num_snippets; i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "%s %s %s", function_prologue, snippets[i].code_snippet,
              function_epilogue);
 
     BytecodeGraphTester tester(isolate, zone, script.start(), "t");
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 
+TEST(BytecodeGraphBuilderLookupSlotWide) {
+  HandleAndZoneScope scope;
+  Isolate* isolate = scope.main_isolate();
+  Zone* zone = scope.main_zone();
+  Factory* factory = isolate->factory();
+
+  const char* function_prologue =
+      "var f;"
+      "var x = 12;"
+      "y = 10;"
+      "var obj = {val:3.1414};"
+      "var z = 30;"
+      "function f1() {"
+      "  var z = 20;"
+      "  eval(\"function t() {";
+  const char* function_epilogue =
+      "        }; f = t; t();\");"
+      "}"
+      "f1();";
+  std::ostringstream str;
+  str << "var y = 2.3; ";
+  for (int i = 1; i < 256; i++) {
+    str << "y = " << 2.3 + i << "; ";
+  }
+  std::string init_function_body = str.str();
+
+  std::pair<std::string, Handle<Object>> snippets[] = {
+      {init_function_body + "return x;", factory->NewNumber(12)},
+      {init_function_body + "return typeof x;",
+       factory->NewStringFromStaticChars("number")},
+      {init_function_body + "return x = 23;", factory->NewNumber(23)},
+      {"'use strict';" + init_function_body + "return obj.val = 23.456;",
+       factory->NewNumber(23.456)}};
+
+  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
+  for (size_t i = 0; i < num_snippets; i++) {
+    ScopedVector<char> script(3072);
+    SNPrintF(script, "%s %s %s", function_prologue, snippets[i].first.c_str(),
+             function_epilogue);
+
+    BytecodeGraphTester tester(isolate, zone, script.start(), "t");
+    auto callable = tester.GetCallable<>();
+    Handle<Object> return_value = callable().ToHandleChecked();
+    CHECK(return_value->SameValue(*snippets[i].second));
+  }
+}
+
+
 bool get_compare_result(Token::Value opcode, Handle<Object> lhs_value,
                         Handle<Object> rhs_value) {
   switch (opcode) {
     case Token::Value::EQ:
       return Object::Equals(lhs_value, rhs_value).FromJust();
     case Token::Value::NE:
       return !Object::Equals(lhs_value, rhs_value).FromJust();
     case Token::Value::EQ_STRICT:
       return lhs_value->StrictEquals(*rhs_value);
     case Token::Value::NE_STRICT:
@@ skipping 1033 matching lines @@
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8