[Interpreter] Add wide varients of bytecodes with feedback and constant pool indexes.

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 37 matching lines @@
                                      const char* function_name) {
     CompileRun(script);
     Local<Function> function =
         Local<Function>::Cast(CcTest::global()->Get(v8_str(function_name)));
     i::Handle<i::JSFunction> js_function =
         i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*function));
     return handle(js_function->shared()->bytecode_array(), CcTest::i_isolate());
   }
 
   Handle<BytecodeArray> MakeBytecodeForFunctionBody(const char* body) {
-    ScopedVector<char> program(1024);
+    ScopedVector<char> program(3072);
     SNPrintF(program, "function %s() { %s }\n%s();", kFunctionName, body,
              kFunctionName);
     return MakeBytecode(program.start(), kFunctionName);
   }
 
   Handle<BytecodeArray> MakeBytecodeForFunction(const char* function) {
-    ScopedVector<char> program(1024);
+    ScopedVector<char> program(3072);
     SNPrintF(program, "%s\n%s();", function, kFunctionName);
     return MakeBytecode(program.start(), kFunctionName);
   }
 
   Handle<BytecodeArray> MakeBytecodeForFunctionNoFilter(const char* function) {
     const char* old_ignition_filter = i::FLAG_ignition_filter;
     i::FLAG_ignition_filter = "*";
-    ScopedVector<char> program(1024);
+    ScopedVector<char> program(3072);
     SNPrintF(program, "%s\n%s();", function, kFunctionName);
     Handle<BytecodeArray> return_val =
         MakeBytecode(program.start(), kFunctionName);
     i::FLAG_ignition_filter = old_ignition_filter;
     return return_val;
   }
 };
 
 
 // Helper macros for handcrafting bytecode sequences.
 #define B(x) static_cast<uint8_t>(Bytecode::k##x)
 #define U8(x) static_cast<uint8_t>((x) & 0xff)
 #define R(x) static_cast<uint8_t>(-(x) & 0xff)
 #define A(x, n) R(helper.kLastParamIndex - (n) + 1 + (x))
 #define THIS(n) A(0, n)
 #if defined(V8_TARGET_LITTLE_ENDIAN)
 #define U16(x) static_cast<uint8_t>((x) & 0xff),                    \
                static_cast<uint8_t>(((x) >> kBitsPerByte) & 0xff)
 #elif defined(V8_TARGET_BIG_ENDIAN)
 #define U16(x) static_cast<uint8_t>(((x) >> kBitsPerByte) & 0xff),   \
                static_cast<uint8_t>((x) & 0xff)
 #else
 #error Unknown byte ordering
 #endif
 
+#define COMMA() ,
+#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__
 
 // Structure for containing expected bytecode snippets.
-template<typename T>
+template<typename T, int C = 6>
 struct ExpectedSnippet {
   const char* code_snippet;
   int frame_size;
   int parameter_count;
   int bytecode_length;
-  const uint8_t bytecode[512];
+  const uint8_t bytecode[2048];
   int constant_count;
-  T constants[6];
+  T constants[C];
 };
 
 
 static void CheckConstant(int expected, Object* actual) {
   CHECK_EQ(expected, Smi::cast(actual)->value());
 }
 
 
 static void CheckConstant(double expected, Object* actual) {
   CHECK_EQ(expected, HeapNumber::cast(actual)->value());
@@ skipping 10 matching lines @@
 static void CheckConstant(Handle<Object> expected, Object* actual) {
   CHECK(actual == *expected || expected->StrictEquals(actual));
 }
 
 
 static void CheckConstant(InstanceType expected, Object* actual) {
   CHECK_EQ(expected, HeapObject::cast(actual)->map()->instance_type());
 }
 
 
-template <typename T>
-static void CheckBytecodeArrayEqual(const ExpectedSnippet<T>& expected,
+template <typename T, int C>
+static void CheckBytecodeArrayEqual(const ExpectedSnippet<T, C>& expected,
                                     Handle<BytecodeArray> actual) {
   CHECK_EQ(expected.frame_size, actual->frame_size());
   CHECK_EQ(expected.parameter_count, actual->parameter_count());
   CHECK_EQ(expected.bytecode_length, actual->length());
   if (expected.constant_count == 0) {
     CHECK_EQ(CcTest::heap()->empty_fixed_array(), actual->constant_pool());
   } else {
     CHECK_EQ(expected.constant_count, actual->constant_pool()->length());
     for (int i = 0; i < expected.constant_count; i++) {
       CheckConstant(expected.constants[i], actual->constant_pool()->get(i));
@@ skipping 266 matching lines @@
         B(LdaSmi8), U8(4),              //
         B(Star), R(2),                  //
         B(Ldar), R(0),                  //
         B(JumpIfToBooleanTrue), U8(8),  //
         B(LdaSmi8), U8(5),              //
         B(Star), R(2),                  //
         B(LdaSmi8), U8(3),              //
         B(Return)},
        0},
       {"var x = 1; var a = 2, b = 3; return x || ("
-#define X "a = 1, b = 2, "
-       X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
-#undef X
+       REPEAT_32(SPACE, "a = 1, b = 2, ")
        "3);",
        3 * kPointerSize,
        1,
-       283,
+       275,
        {B(LdaSmi8), U8(1),                      //
         B(Star), R(0),                          //
         B(LdaSmi8), U8(2),                      //
         B(Star), R(1),                          //
         B(LdaSmi8), U8(3),                      //
         B(Star), R(2),                          //
         B(Ldar), R(0),                          //
         B(JumpIfToBooleanTrueConstant), U8(0),  //
-#define X B(LdaSmi8), U8(1), B(Star), R(1), B(LdaSmi8), U8(2), B(Star), R(2),
-        X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
-#undef X
+        REPEAT_32(COMMA,                        //
+          B(LdaSmi8), U8(1),                    //
+          B(Star), R(1),                        //
+          B(LdaSmi8), U8(2),                    //
+          B(Star), R(2)),                       //
         B(LdaSmi8), U8(3),                      //
         B(Return)},
        1,
-       {268, 0, 0, 0}},
+       {260, 0, 0, 0}},
       {"var x = 0; var a = 2, b = 3; return x && ("
-#define X "a = 1, b = 2, "
-       X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
-#undef X
+       REPEAT_32(SPACE, "a = 1, b = 2, ")
        "3);",
        3 * kPointerSize,
        1,
-       282,
+       274,
        {B(LdaZero),                              //
         B(Star), R(0),                           //
         B(LdaSmi8), U8(2),                       //
         B(Star), R(1),                           //
         B(LdaSmi8), U8(3),                       //
         B(Star), R(2),                           //
         B(Ldar), R(0),                           //
         B(JumpIfToBooleanFalseConstant), U8(0),  //
-#define X B(LdaSmi8), U8(1), B(Star), R(1), B(LdaSmi8), U8(2), B(Star), R(2),
-        X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
-#undef X
-        B(LdaSmi8), U8(3),  //
-        B(Return)},
+        REPEAT_32(COMMA,                         //
+          B(LdaSmi8), U8(1),                     //
+          B(Star), R(1),                         //
+          B(LdaSmi8), U8(2),                     //
+          B(Star), R(2)),                        //
+        B(LdaSmi8), U8(3),                       //
+        B(Return)},                              //
        1,
-       {268, 0, 0, 0}},
+       {260, 0, 0, 0}},
       {"return 0 && 3;",
        0 * kPointerSize,
        1,
        2,
        {B(LdaZero),  //
         B(Return)},
        0},
       {"return 1 || 3;",
        0 * kPointerSize,
        1,
@@ skipping 132 matching lines @@
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(HeapNumberConstants) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
-  ExpectedSnippet<double> snippets[] = {
+  int wide_idx = 0;
+
+  ExpectedSnippet<double, 257> snippets[] = {
     {"return 1.2;",
      0,
      1,
      3,
      {
        B(LdaConstant), U8(0),  //
        B(Return)               //
      },
      1,
      {1.2}},
@@ skipping 13 matching lines @@
      1 * kPointerSize,
      1,
      7,
      {
        B(LdaConstant), U8(0),  //
        B(Star), R(0),          //
        B(LdaConstant), U8(1),  //
        B(Return)               //
      },
      2,
-     {3.14, 3.14}}};
+     {3.14, 3.14}},
+    {"var a;"
+     REPEAT_256(SPACE, " a = 1.414;")
+     " a = 3.14;",
+     1 * kPointerSize,
+     1,
+     1031,
+     {
+         REPEAT_256(COMMA,                     //
+           B(LdaConstant), U8(wide_idx++),     //
+           B(Star), R(0)),                     //
+         B(LdaConstantWide), U16(wide_idx++),  //
+         B(Star), R(0),                        //
+         B(LdaUndefined),                      //
+         B(Return),                            //
+     },
+     257,
+     {REPEAT_256(COMMA, 1.414),
+      3.14}}
+  };
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(StringConstants) {
   InitializedHandleScope handle_scope;
@@ skipping 48 matching lines @@
   BytecodeGeneratorHelper helper;
   Zone zone;
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot1 = feedback_spec.AddLoadICSlot();
   FeedbackVectorSlot slot2 = feedback_spec.AddLoadICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
 
+  // These are a hack used by the LoadICXXXWide tests below.
+  int wide_idx_1 = vector->GetIndex(slot1) - 2;
+  int wide_idx_2 = vector->GetIndex(slot1) - 2;
+  int wide_idx_3 = vector->GetIndex(slot1) - 2;
+  int wide_idx_4 = vector->GetIndex(slot1) - 2;
+
   ExpectedSnippet<const char*> snippets[] = {
       {"function f(a) { return a.name; }\nf({name : \"test\"})",
        0,
        2,
        5,
        {
            B(LoadICSloppy), A(1, 2), U8(0), U8(vector->GetIndex(slot1)),  //
            B(Return),                                                     //
        },
        1,
@@ skipping 56 matching lines @@
           "function f(a, b) { \"use strict\"; return a[b]; }\n"
           "f({arg : \"test\"}, \"arg\")",
           0,
           3,
           6,
           {
               B(Ldar), A(2, 3),                                            //
               B(KeyedLoadICStrict), A(1, 3), U8(vector->GetIndex(slot1)),  //
               B(Return),                                                   //
           },
-          0,
-      }};
+          0},
+      {
+          "function f(a) {\n"
+          " var b;\n"
+          REPEAT_127(SPACE, " b = a.name; ")
+          " return a.name; }\n"
+          "f({name : \"test\"})\n",
+          1 * kPointerSize,
+          2,
+          769,
+          {
+              REPEAT_127(COMMA,                                            //
+                B(LoadICSloppy), A(1, 2), U8(0), U8((wide_idx_1 += 2)),    //
+                B(Star), R(0)),                                            //
+              B(LoadICSloppyWide), A(1, 2), U16(0), U16(wide_idx_1 += 2),  //
+              B(Return),                                                   //
+          },
+          1,
+          {"name"}},
+      {
+          "function f(a) {\n"
+          " 'use strict'; var b;\n"
+          REPEAT_127(SPACE, " b = a.name; ")
+          " return a.name; }\n"
+          "f({name : \"test\"})\n",
+          1 * kPointerSize,
+          2,
+          769,
+          {
+              REPEAT_127(COMMA,                                            //
+                B(LoadICStrict), A(1, 2), U8(0), U8((wide_idx_2 += 2)),    //
+                B(Star), R(0)),                                            //
+              B(LoadICStrictWide), A(1, 2), U16(0), U16(wide_idx_2 += 2),  //
+              B(Return),                                                   //
+          },
+          1,
+          {"name"}},
+      {
+          "function f(a, b) {\n"
+          " var c;\n"
+          REPEAT_127(SPACE, " c = a[b]; ")
+          " return a[b]; }\n"
+          "f({name : \"test\"}, \"name\")\n",
+          1 * kPointerSize,
+          3,
+          896,
+          {
+              REPEAT_127(COMMA,                                         //
+                B(Ldar), A(2, 3),                                       //
+                B(KeyedLoadICSloppy), A(1, 3), U8((wide_idx_3 += 2)),   //
+                B(Star), R(0)),                                         //
+              B(Ldar), A(2, 3),                                         //
+              B(KeyedLoadICSloppyWide), A(1, 3), U16(wide_idx_3 += 2),  //
+              B(Return),                                                //
+          }},
+      {
+          "function f(a, b) {\n"
+          " 'use strict'; var c;\n"
+          REPEAT_127(SPACE, " c = a[b]; ")
+          " return a[b]; }\n"
+          "f({name : \"test\"}, \"name\")\n",
+          1 * kPointerSize,
+          3,
+          896,
+          {
+              REPEAT_127(COMMA,                                         //
+                B(Ldar), A(2, 3),                                       //
+                B(KeyedLoadICStrict), A(1, 3), U8((wide_idx_4 += 2)),   //
+                B(Star), R(0)),                                         //
+              B(Ldar), A(2, 3),                                         //
+              B(KeyedLoadICStrictWide), A(1, 3), U16(wide_idx_4 += 2),  //
+              B(Return),                                                //
+          }},
+      };
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(PropertyStores) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
   Zone zone;
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot1 = feedback_spec.AddStoreICSlot();
   FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
 
+  // These are a hack used by the StoreICXXXWide tests below.
+  int wide_idx_1 = vector->GetIndex(slot1) - 2;
+  int wide_idx_2 = vector->GetIndex(slot1) - 2;
+  int wide_idx_3 = vector->GetIndex(slot1) - 2;
+  int wide_idx_4 = vector->GetIndex(slot1) - 2;
+
   ExpectedSnippet<const char*> snippets[] = {
       {"function f(a) { a.name = \"val\"; }\nf({name : \"test\"})",
        0,
        2,
        8,
        {
            B(LdaConstant), U8(1),                                          //
            B(StoreICSloppy), A(1, 2), U8(0), U8(vector->GetIndex(slot1)),  //
            B(LdaUndefined),                                                //
            B(Return),                                                      //
@@ skipping 73 matching lines @@
        3,
        8,
        {
            B(LdaConstant), U8(0),                               //
            B(KeyedStoreICStrict), A(1, 3), A(2, 3),             //
                                   U8(vector->GetIndex(slot1)),  //
            B(LdaUndefined),                                     //
            B(Return),                                           //
        },
        1,
-       {"val"}}};
+       {"val"}},
+      {"function f(a) {\n"
+       REPEAT_127(SPACE, " a.name = 1; ")
+       " a.name = 2; }\n"
+       "f({name : \"test\"})\n",
+       0,
+       2,
+       772,
+       {
+           REPEAT_127(COMMA,                                             //
+             B(LdaSmi8), U8(1),                                          //
+             B(StoreICSloppy), A(1, 2), U8(0), U8((wide_idx_1 += 2))),   //
+           B(LdaSmi8), U8(2),                                            //
+           B(StoreICSloppyWide), A(1, 2), U16(0), U16(wide_idx_1 += 2),  //
+           B(LdaUndefined),                                              //
+           B(Return),                                                    //
+       },
+       1,
+       {"name"}},
+      {"function f(a) {\n"
+       "'use strict';\n"
+       REPEAT_127(SPACE, " a.name = 1; ")
+       " a.name = 2; }\n"
+       "f({name : \"test\"})\n",
+       0,
+       2,
+       772,
+       {
+           REPEAT_127(COMMA,                                             //
+             B(LdaSmi8), U8(1),                                          //
+             B(StoreICStrict), A(1, 2), U8(0), U8((wide_idx_2 += 2))),   //
+           B(LdaSmi8), U8(2),                                            //
+           B(StoreICStrictWide), A(1, 2), U16(0), U16(wide_idx_2 += 2),  //
+           B(LdaUndefined),                                              //
+           B(Return),                                                    //
+       },
+       1,
+       {"name"}},
+      {"function f(a, b) {\n"
+       REPEAT_127(SPACE, " a[b] = 1; ")
+       " a[b] = 2; }\n"
+       "f({name : \"test\"})\n",
+       0,
+       3,
+       771,
+       {
+           REPEAT_127(COMMA,                                                  //
+             B(LdaSmi8), U8(1),                                               //
+             B(KeyedStoreICSloppy), A(1, 3), A(2, 3),                         //
+                                    U8((wide_idx_3 += 2))),                   //
+           B(LdaSmi8), U8(2),                                                 //
+           B(KeyedStoreICSloppyWide), A(1, 3), A(2, 3),                       //
+                                      U16(wide_idx_3 += 2),                   //
+           B(LdaUndefined),                                                   //
+           B(Return),                                                         //
+       }},
+      {"function f(a, b) {\n"
+       "'use strict';\n"
+       REPEAT_127(SPACE, " a[b] = 1; ")
+       " a[b] = 2; }\n"
+       "f({name : \"test\"})\n",
+       0,
+       3,
+       771,
+       {
+           REPEAT_127(COMMA,                                                  //
+             B(LdaSmi8), U8(1),                                               //
+             B(KeyedStoreICStrict), A(1, 3), A(2, 3),                         //
+                                    U8((wide_idx_4 += 2))),                   //
+           B(LdaSmi8), U8(2),                                                 //
+           B(KeyedStoreICStrictWide), A(1, 3), A(2, 3),                       //
+                                      U16(wide_idx_4 += 2),                   //
+           B(LdaUndefined),                                                   //
+           B(Return),                                                         //
+       }}};
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 #define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
 
@@ skipping 75 matching lines @@
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
   Zone zone;
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
 
+  // These are a hack used by the LdaGlobalXXXWide tests below.
+  int wide_idx_1 = vector->GetIndex(slot) - 2;
+  int wide_idx_2 = vector->GetIndex(slot) - 2;
+
   ExpectedSnippet<const char*> snippets[] = {
       {"var a = 1;\nfunction f() { return a; }\nf()",
        0,
        1,
        4,
        {
            B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)),  //
            B(Return)                                               //
        },
        1,
@@ skipping 21 matching lines @@
       {"a = 1;\nfunction f() { return a; }\nf()",
        0,
        1,
        4,
        {
            B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)),  //
            B(Return)                                               //
        },
        1,
        {"a"}},
+      {"a = 1; function f(b) {\n"
+       REPEAT_127(SPACE, "b.name; ")
+       " return a; }\nf({name: 1});",
+       0,
+       2,
+       514,
+       {
+           REPEAT_127(COMMA,                                         //
+             B(LoadICSloppy), A(1, 2), U8(0), U8(wide_idx_1 += 2)),  //
+           B(LdaGlobalSloppyWide), U16(1), U16(wide_idx_1 += 2),     //
+           B(Return),                                                //
+       },
+       2,
+       {"name", "a"}},
+      {"a = 1; function f(b) {\n"
+       " 'use strict';\n"
+       REPEAT_127(SPACE, "b.name; ")
+       " return a; }\nf({name: 1});",
+       0,
+       2,
+       514,
+       {
+           REPEAT_127(COMMA,                                         //
+             B(LoadICStrict), A(1, 2), U8(0), U8(wide_idx_2 += 2)),  //
+           B(LdaGlobalStrictWide), U16(1), U16(wide_idx_2 += 2),     //
+           B(Return),                                                //
+       },
+       2,
+       {"name", "a"}},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, "f");
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(StoreGlobal) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
   Zone zone;
 
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddStoreICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
 
+  // These are a hack used by the StaGlobalXXXWide tests below.
+  int wide_idx_1 = vector->GetIndex(slot) - 2;
+  int wide_idx_2 = vector->GetIndex(slot) - 2;
+
   ExpectedSnippet<const char*> snippets[] = {
       {"var a = 1;\nfunction f() { a = 2; }\nf()",
        0,
        1,
        7,
        {
            B(LdaSmi8), U8(2),                                      //
            B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)),  //
            B(LdaUndefined),                                        //
            B(Return)                                               //
@@ skipping 29 matching lines @@
        1,
        7,
        {
            B(LdaSmi8), U8(2),                                      //
            B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)),  //
            B(LdaUndefined),                                        //
            B(Return)                                               //
        },
        1,
        {"a"}},
+      {"a = 1; function f(b) {\n"
+       REPEAT_127(SPACE, "b.name; ")
+       " a = 2; }\nf({name: 1});",
+       0,
+       2,
+       517,
+       {
+           REPEAT_127(COMMA,                                         //
+             B(LoadICSloppy), A(1, 2), U8(0), U8(wide_idx_1 += 2)),  //
+           B(LdaSmi8), U8(2),                                        //
+           B(StaGlobalSloppyWide), U16(1), U16(wide_idx_1 += 2),     //
+           B(LdaUndefined),                                          //
+           B(Return),                                                //
+       },
+       2,
+       {"name", "a"}},
+      {"a = 1; function f(b) {\n"
+       " 'use strict';\n"
+       REPEAT_127(SPACE, "b.name; ")
+       " a = 2; }\nf({name: 1});",
+       0,
+       2,
+       517,
+       {
+           REPEAT_127(COMMA,                                         //
+             B(LoadICStrict), A(1, 2), U8(0), U8(wide_idx_2 += 2)),  //
+           B(LdaSmi8), U8(2),                                        //
+           B(StaGlobalStrictWide), U16(1), U16(wide_idx_2 += 2),     //
+           B(LdaUndefined),                                          //
+           B(Return),                                                //
+       },
+       2,
+       {"name", "a"}},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, "f");
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
@@ skipping 191 matching lines @@
         B(TestIn), A(1, 3),     //
         B(JumpIfFalse), U8(5),  //
         B(LdaConstant), U8(0),  //
         B(Return),              //
         B(LdaUndefined),        //
         B(Return)},             //
        1,
        {helper.factory()->NewNumberFromInt(200), unused, unused, unused, unused,
         unused}},
       {"function f(z) { var a = 0; var b = 0; if (a === 0.01) { "
-#define X "b = a; a = b; "
-       X X X X X X X X X X X X X X X X X X X X X X X X
-#undef X
+       REPEAT_32(SPACE, "b = a; a = b; ")
        " return 200; } else { return -200; } } f(0.001)",
        2 * kPointerSize,
        2,
-       214,
+       278,
        {
-#define X B(Ldar), R(0), B(Star), R(1), B(Ldar), R(1), B(Star), R(0)
            B(LdaZero),                     //
            B(Star), R(0),                  //
            B(LdaZero),                     //
            B(Star), R(1),                  //
            B(LdaConstant), U8(0),          //
            B(TestEqualStrict), R(0),       //
            B(JumpIfFalseConstant), U8(2),  //
-           X, X, X, X, X, X, X, X, X, X,   //
-           X, X, X, X, X, X, X, X, X, X,   //
-           X, X, X, X,                     //
+           REPEAT_32(COMMA,                //
+             B(Ldar), R(0),                //
+             B(Star), R(1),                //
+             B(Ldar), R(1),                //
+             B(Star), R(0)),               //
            B(LdaConstant), U8(1),          //
            B(Return),                      //
            B(Jump), U8(5),                 //
            B(LdaConstant), U8(3),          //
            B(Return),                      //
            B(LdaUndefined),                //
            B(Return)},                     //
-#undef X
        4,
        {helper.factory()->NewHeapNumber(0.01),
         helper.factory()->NewNumberFromInt(200),
-        helper.factory()->NewNumberFromInt(199),
+        helper.factory()->NewNumberFromInt(263),
         helper.factory()->NewNumberFromInt(-200), unused, unused}},
       {"function f(a, b) {\n"
        "  if (a == b) { return 1; }\n"
        "  if (a === b) { return 1; }\n"
        "  if (a < b) { return 1; }\n"
        "  if (a > b) { return 1; }\n"
        "  if (a <= b) { return 1; }\n"
        "  if (a >= b) { return 1; }\n"
        "  if (a in b) { return 1; }\n"
        "  if (a instanceof b) { return 1; }\n"
        "  return 0;\n"
        "} f(1, 1);",
        0,
        3,
        74,
        {
 #define IF_CONDITION_RETURN(condition) \
-  B(Ldar), A(2, 3),             \
+         B(Ldar), A(2, 3),             \
          B(condition), A(1, 3),        \
          B(JumpIfFalse), U8(5),        \
          B(LdaSmi8), U8(1),            \
          B(Return),
            IF_CONDITION_RETURN(TestEqual)               //
            IF_CONDITION_RETURN(TestEqualStrict)         //
            IF_CONDITION_RETURN(TestLessThan)            //
            IF_CONDITION_RETURN(TestGreaterThan)         //
            IF_CONDITION_RETURN(TestLessThanOrEqual)     //
            IF_CONDITION_RETURN(TestGreaterThanOrEqual)  //
@@ skipping 2669 matching lines @@
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8