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

test/cctest/interpreter/test-bytecode-generator.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 "src/v8.h"
 
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 5820 matching lines @@
                          std::string(function_epilogue);
     // TODO(mythria): use * as filter when function declarations are supported
     // inside eval.
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(script.c_str(), "t", "f");
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
+TEST(LookupSlotWideInEval) {
+  InitializedHandleScope handle_scope;
+  BytecodeGeneratorHelper helper;
+
+  const char* function_prologue =
+      "var f;"
+      "var x = 1;"
+      "function f1() {"
+      "  eval(\"function t() {";
+  const char* function_epilogue =
+      "        }; f = t; f();\");"
+      "}"
+      "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::string function_body[] = {
+      init_function_body + "return x;", init_function_body + "return typeof x;",
+      init_function_body + "x = 10;",
+      "'use strict';" + init_function_body + "x = 10;"};
+  int const_count[] = {0, 0, 0, 0};
+
+  ExpectedSnippet<InstanceType, 257> snippets[] = {
+      {function_body[0].c_str(),

[rmcilroy, 2016/01/04 15:22:32]

I would prefer you just put the actual function code directly in here for each
test. There is no deduping of double values in the constant pool, so you can
just put the same heap number in a bunch of times to get the result you want,
i.e.: 
  REPEAT_256(SPACE, "var y = 2.3;")
  "return x;"

[mythria, 2016/01/05 10:07:26]

Thanks,
Done.

+       1 * kPointerSize,
+       1,
+       1028,
+       {
+           REPEAT_256(SPACE,                         //
+             B(LdaConstant), U8(const_count[0]++),   //
+             B(Star), R(0), )                        //
+           B(LdaLookupSlotWide), U16(256),           //
+           B(Return)                                 //
+       },
+       257,
+       {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+        InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+      {function_body[1].c_str(),
+       1 * kPointerSize,
+       1,
+       1029,
+       {
+           REPEAT_256(SPACE,                            //
+             B(LdaConstant), U8(const_count[1]++),      //
+             B(Star), R(0), )                           //
+           B(LdaLookupSlotInsideTypeofWide), U16(256),  //
+           B(TypeOf),                                   //
+           B(Return)                                    //
+       },
+       257,
+       {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+        InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+      {function_body[2].c_str(),
+       1 * kPointerSize,
+       1,
+       1031,
+       {
+           REPEAT_256(SPACE,                        //
+             B(LdaConstant), U8(const_count[2]++),  //
+             B(Star), R(0), )                       //
+           B(LdaSmi8), U8(10),                      //
+           B(StaLookupSlotSloppyWide), U16(256),    //
+           B(LdaUndefined),                         //
+           B(Return)                                //
+       },
+       257,
+       {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+        InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+      {function_body[3].c_str(),
+       1 * kPointerSize,
+       1,
+       1031,
+       {
+           REPEAT_256(SPACE,
+             B(LdaConstant), U8(const_count[3]++),  //
+             B(Star), R(0), )                       //
+           B(LdaSmi8), U8(10),                      //
+           B(StaLookupSlotStrictWide), U16(256),    //
+           B(LdaUndefined),                         //
+           B(Return)                                //
+       },
+       257,
+       {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+        InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+  };
+
+  for (size_t i = 0; i < arraysize(snippets); i++) {
+    std::string script = std::string(function_prologue) +
+                         std::string(snippets[i].code_snippet) +
+                         std::string(function_epilogue);
+    // TODO(mythria): use * as filter when function declarations are supported
+    // inside eval.
+    Handle<BytecodeArray> bytecode_array =
+        helper.MakeBytecode(script.c_str(), "t", "f");
+    CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+  }
+}
+
+
 TEST(DeleteLookupSlot) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   const char* function_prologue = "var f;"
                                   "var x = 1;"
                                   "z = 10;"
                                   "function f1() {"
                                   "  var y;"
                                   "  eval(\"function t() {";
@@ skipping 42 matching lines @@
                          std::string(function_epilogue);
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(script.c_str(), "t", "f");
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8