[test] Shard some slower bytecode graph builder tests.

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"
 #include "src/interpreter/interpreter.h"
 #include "src/parsing/parser.h"
 #include "test/cctest/cctest.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+#define SHARD_TEST_BY_2(x)    \
+  TEST(x##_0) { Test##x(0); } \
+  TEST(x##_1) { Test##x(1); }
+#define SHARD_TEST_BY_4(x)    \
+  TEST(x##_0) { Test##x(0); } \
+  TEST(x##_1) { Test##x(1); } \
+  TEST(x##_2) { Test##x(2); } \
+  TEST(x##_3) { Test##x(3); }
 
 static const char kFunctionName[] = "f";
 
 static const Token::Value kCompareOperators[] = {
     Token::Value::EQ,        Token::Value::NE, Token::Value::EQ_STRICT,
     Token::Value::NE_STRICT, Token::Value::LT, Token::Value::LTE,
     Token::Value::GT,        Token::Value::GTE};
 
 static const int SMI_MAX = (1 << 30) - 1;
 static const int SMI_MIN = -(1 << 30);
@@ skipping 169 matching lines @@
       {"return -1;", {factory->NewNumberFromInt(-1)}},
       {"return +127;", {factory->NewNumberFromInt(127)}},
       {"return -128;", {factory->NewNumberFromInt(-128)}},
       {"return 0.001;", {factory->NewNumber(0.001)}},
       {"return 3.7e-60;", {factory->NewNumber(3.7e-60)}},
       {"return -3.7e60;", {factory->NewNumber(-3.7e60)}},
       {"return '';", {factory->NewStringFromStaticChars("")}},
       {"return 'catfood';", {factory->NewStringFromStaticChars("catfood")}},
       {"return NaN;", {factory->nan_value()}}};
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 
 TEST(BytecodeGraphBuilderPrimitiveExpressions) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
   Factory* factory = isolate->factory();
 
   ExpectedSnippet<0> snippets[] = {
       {"return 1 + 1;", {factory->NewNumberFromInt(2)}},
       {"return 20 - 30;", {factory->NewNumberFromInt(-10)}},
       {"return 4 * 100;", {factory->NewNumberFromInt(400)}},
       {"return 100 / 5;", {factory->NewNumberFromInt(20)}},
       {"return 25 % 7;", {factory->NewNumberFromInt(4)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
@@ skipping 37 matching lines @@
         factory->NewHeapNumber(6.666)}},
       {"return p1 / p2;",
        {factory->NewHeapNumber(2.25), factory->NewHeapNumber(9),
         factory->NewHeapNumber(4)}},
       // Strings
       {"return p1 + p2;",
        {factory->NewStringFromStaticChars("abcdef"),
         factory->NewStringFromStaticChars("abc"),
         factory->NewStringFromStaticChars("def")}}};
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1, p2) { %s }\n%s(0, 0);", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>, Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0), snippets[i].parameter(1))
             .ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
@@ skipping 23 matching lines @@
       {"var b;\n" REPEAT_127(SPACE, " b = p1.name; ") " return p1.name;\n",
        {factory->NewStringFromStaticChars("abc"),
         BytecodeGraphTester::NewObject("({name : 'abc'})")}},
       {"'use strict'; var b;\n"
        REPEAT_127(SPACE, " b = p1.name; ")
        "return p1.name;\n",
        {factory->NewStringFromStaticChars("abc"),
         BytecodeGraphTester::NewObject("({ name : 'abc'})")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(2048);
     SNPrintF(script, "function %s(p1) { %s };\n%s(0);", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 35 matching lines @@
        {factory->NewStringFromStaticChars("abc"),
         BytecodeGraphTester::NewObject("({100 : 'abc'})"),
         factory->NewNumberFromInt(100)}},
       {"'use strict'; var b;\n" REPEAT_127(SPACE,
                                            " b = p1[p2]; ") "return p1[p2];\n",
        {factory->NewStringFromStaticChars("abc"),
         BytecodeGraphTester::NewObject("({ 100 : 'abc'})"),
         factory->NewNumberFromInt(100)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(2048);
     SNPrintF(script, "function %s(p1, p2) { %s };\n%s(0);", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>, Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0), snippets[i].parameter(1))
             .ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
-
-TEST(BytecodeGraphBuilderNamedStore) {
+void TestBytecodeGraphBuilderNamedStore(size_t shard) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
   Factory* factory = isolate->factory();
 
   ExpectedSnippet<1> snippets[] = {
       {"return p1.val = 20;",
        {factory->NewNumberFromInt(20),
         BytecodeGraphTester::NewObject("({val : 10})")}},
       {"p1.type = 'int'; return p1.type;",
@@ skipping 14 matching lines @@
       {"var b = 'abc';\n" REPEAT_127(
            SPACE, " p1.name = b; ") " p1.name = 'def'; return p1.name;\n",
        {factory->NewStringFromStaticChars("def"),
         BytecodeGraphTester::NewObject("({name : 'abc'})")}},
       {"'use strict'; var b = 'def';\n" REPEAT_127(
            SPACE, " p1.name = 'abc'; ") "p1.name = b; return p1.name;\n",
        {factory->NewStringFromStaticChars("def"),
         BytecodeGraphTester::NewObject("({ name : 'abc'})")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
+    if ((i % 2) != shard) continue;
     ScopedVector<char> script(3072);
     SNPrintF(script, "function %s(p1) { %s };\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
+SHARD_TEST_BY_2(BytecodeGraphBuilderNamedStore)
 
-TEST(BytecodeGraphBuilderKeyedStore) {
+void TestBytecodeGraphBuilderKeyedStore(size_t shard) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
   Factory* factory = isolate->factory();
 
   ExpectedSnippet<2> snippets[] = {
       {"p1[p2] = 20; return p1[p2];",
        {factory->NewNumberFromInt(20),
         BytecodeGraphTester::NewObject("({val : 10})"),
         factory->NewStringFromStaticChars("val")}},
@@ skipping 22 matching lines @@
        {factory->NewStringFromStaticChars("def"),
         BytecodeGraphTester::NewObject("({100 : 'abc'})"),
         factory->NewNumberFromInt(100)}},
       {"'use strict'; var b;\n" REPEAT_127(
            SPACE, " b = p1[p2]; ") " p1[p2] = 'def'; return p1[p2];\n",
        {factory->NewStringFromStaticChars("def"),
         BytecodeGraphTester::NewObject("({ 100 : 'abc'})"),
         factory->NewNumberFromInt(100)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
+    if ((i % 2) != shard) continue;
     ScopedVector<char> script(2048);
     SNPrintF(script, "function %s(p1, p2) { %s };\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
+SHARD_TEST_BY_2(BytecodeGraphBuilderKeyedStore)
 
 TEST(BytecodeGraphBuilderPropertyCall) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
   Factory* factory = isolate->factory();
 
   ExpectedSnippet<1> snippets[] = {
       {"return p1.func();",
        {factory->NewNumberFromInt(25),
         BytecodeGraphTester::NewObject("({func() { return 25; }})")}},
       {"return p1.func('abc');",
        {factory->NewStringFromStaticChars("abc"),
         BytecodeGraphTester::NewObject("({func(a) { return a; }})")}},
       {"return p1.func(1, 2, 3, 4, 5, 6, 7, 8);",
        {factory->NewNumberFromInt(36),
         BytecodeGraphTester::NewObject(
             "({func(a, b, c, d, e, f, g, h) {\n"
             "  return a + b + c + d + e + f + g + h;}})")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(2048);
     SNPrintF(script, "function %s(p1) { %s };\n%s({func() {}});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 22 matching lines @@
       {"function counter(arg0, arg1) {\n"
        "  this.count = 17; this.x = arg0; this.y = arg1;\n"
        "}\n"
        "function f() {\n"
        "  var c = new counter(3, 5);\n"
        "  return c.count + c.x + c.y;\n"
        "}; f()",
        {factory->NewNumberFromInt(25)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     BytecodeGraphTester tester(isolate, zone, snippets[i].code_snippet);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 
 TEST(BytecodeGraphBuilderCreateClosure) {
   HandleAndZoneScope scope;
@@ skipping 17 matching lines @@
       {"function f() {\n"
        "  function counter(arg0, arg1) {\n"
        "    this.count = 17; this.x = arg0; this.y = arg1;\n"
        "  }\n"
        "  var c = new counter(3, 5);\n"
        "  return c.count + c.x + c.y;\n"
        "}; f()",
        {factory->NewNumberFromInt(25)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     BytecodeGraphTester tester(isolate, zone, snippets[i].code_snippet);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 
 TEST(BytecodeGraphBuilderCallRuntime) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
   Factory* factory = isolate->factory();
 
   ExpectedSnippet<1> snippets[] = {
       {"function f(arg0) { return %MaxSmi(); }\nf()",
        {factory->NewNumberFromInt(Smi::kMaxValue), factory->undefined_value()}},
       {"function f(arg0) { return %IsArray(arg0) }\nf(undefined)",
        {factory->true_value(), BytecodeGraphTester::NewObject("[1, 2, 3]")}},
       {"function f(arg0) { return %Add(arg0, 2) }\nf(1)",
        {factory->NewNumberFromInt(5), factory->NewNumberFromInt(3)}},
       {"function f(arg0) { return %spread_arguments(arg0).length }\nf([])",
        {factory->NewNumberFromInt(3),
         BytecodeGraphTester::NewObject("[1, 2, 3]")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     BytecodeGraphTester tester(isolate, zone, snippets[i].code_snippet);
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
-
-TEST(BytecodeGraphBuilderGlobals) {
+void TestBytecodeGraphBuilderGlobals(size_t shard) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
   Factory* factory = isolate->factory();
 
   ExpectedSnippet<0> snippets[] = {
       {"var global = 321;\n function f() { return global; };\n f();",
        {factory->NewNumberFromInt(321)}},
       {"var global = 321;\n"
        "function f() { global = 123; return global };\n f();",
@@ skipping 19 matching lines @@
            SPACE, " var b = global_obj.name;\n") "global = 'xyz'; return "
                                                  "global };\n f();\n",
        {factory->NewStringFromStaticChars("xyz")}},
       {"function f() { return typeof(undeclared_var); }\n; f();\n",
        {factory->NewStringFromStaticChars("undefined")}},
       {"var defined_var = 10; function f() { return typeof(defined_var); }\n; "
        "f();\n",
        {factory->NewStringFromStaticChars("number")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
+    if ((i % 2) != shard) continue;
     BytecodeGraphTester tester(isolate, zone, snippets[i].code_snippet);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
+SHARD_TEST_BY_2(BytecodeGraphBuilderGlobals)
 
 TEST(BytecodeGraphBuilderToObject) {
   // TODO(mythria): tests for ToObject. Needs ForIn.
 }
 
 
 TEST(BytecodeGraphBuilderToName) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
@@ skipping 17 matching lines @@
       {"var a = {valueOf : function() { return 'x'}};\n"
        "var obj = {[a] : 10};\n"
        "return obj.x;",
        {factory->undefined_value()}},
       {"var a = {[Symbol.toPrimitive] : function() { return 'x'}};\n"
        "var obj = {[a] : 10};\n"
        "return obj.x;",
        {factory->NewNumberFromInt(10)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
@@ skipping 10 matching lines @@
        {factory->false_value(),
         BytecodeGraphTester::NewObject("({val : 10})")}},
       {"return !p1;", {factory->true_value(), factory->NewNumberFromInt(0)}},
       {"return !p1;", {factory->true_value(), factory->undefined_value()}},
       {"return !p1;", {factory->false_value(), factory->NewNumberFromInt(10)}},
       {"return !p1;", {factory->false_value(), factory->true_value()}},
       {"return !p1;",
        {factory->false_value(), factory->NewStringFromStaticChars("abc")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1) { %s }\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 16 matching lines @@
       {"return typeof p1;",
        {factory->NewStringFromStaticChars("number"),
         factory->NewNumberFromInt(10)}},
       {"return typeof p1;",
        {factory->NewStringFromStaticChars("boolean"), factory->true_value()}},
       {"return typeof p1;",
        {factory->NewStringFromStaticChars("string"),
         factory->NewStringFromStaticChars("abc")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1) { %s }\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 33 matching lines @@
        {factory->NewNumberFromInt(11),
         BytecodeGraphTester::NewObject("({1 : 10})")}},
       {" function inner() { return p1 } return --p1;",
        {factory->NewNumberFromInt(9), factory->NewNumberFromInt(10)}},
       {" function inner() { return p1 } return p1--;",
        {factory->NewNumberFromInt(10), factory->NewNumberFromInt(10)}},
       {"return ++p1;",
        {factory->nan_value(), factory->NewStringFromStaticChars("String")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1) { %s }\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 18 matching lines @@
       {"'use strict'; return delete p1.val;",
        {factory->true_value(), BytecodeGraphTester::NewObject("({val : 10})")}},
       {"'use strict'; delete p1.val; return p1.val;",
        {factory->undefined_value(),
         BytecodeGraphTester::NewObject("({val : 10})")}},
       {"'use strict'; delete p1.name; return p1.val;",
        {factory->NewNumberFromInt(10),
         BytecodeGraphTester::NewObject("({val : 10, name:'abc'})")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1) { %s }\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 33 matching lines @@
        "function f() { delete obj[1]; return obj[2];};",
        {factory->NewNumberFromInt(20)}},
       {"function f() {"
        "  var obj = {1 : 10, 2 : 20};"
        "  function inner() { return obj[1]; };"
        "  return delete obj[1];"
        "}",
        {factory->true_value()}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "%s %s({});", snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
@@ skipping 15 matching lines @@
                                   "  eval(\"function t() {";
   const char* function_epilogue = "        }; f = t; t();\");"
                                   "}"
                                   "f1();";
 
   ExpectedSnippet<0> snippets[] = {
       {"return delete y;", {factory->true_value()}},
       {"return delete z;", {factory->false_value()}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(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()));
   }
 }
@@ skipping 20 matching lines @@
   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++) {
+  for (size_t i = 0; i < arraysize(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()));
   }
 }
@@ skipping 22 matching lines @@
   ExpectedSnippet<0> snippets[] = {
       {"var y = 2.3;" REPEAT_256(SPACE, "y = 2.3;") "return x;",
        {factory->NewNumber(12)}},
       {"var y = 2.3;" REPEAT_256(SPACE, "y = 2.3;") "return typeof x;",
        {factory->NewStringFromStaticChars("number")}},
       {"var y = 2.3;" REPEAT_256(SPACE, "y = 2.3;") "return x = 23;",
        {factory->NewNumber(23)}},
       {"'use strict';" REPEAT_256(SPACE, "y = 2.3;") "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++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(3072);
     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(BytecodeGraphBuilderCallLookupSlot) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
 
   ExpectedSnippet<0> snippets[] = {
       {"g = function(){ return 2 }; eval(''); return g();",
        {handle(Smi::FromInt(2), isolate)}},
       {"g = function(){ return 2 }; eval('g = function() {return 3}');\n"
        "return g();",
        {handle(Smi::FromInt(3), isolate)}},
       {"g = { x: function(){ return this.y }, y: 20 };\n"
        "eval('g = { x: g.x, y: 30 }');\n"
        "return g.x();",
        {handle(Smi::FromInt(30), isolate)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
@@ skipping 31 matching lines @@
       {"'use strict'; eval('var y = 10;'); return typeof unallocated;",
        {factory->NewStringFromStaticChars("undefined")}},
       {"eval('var x = 10;'); return typeof x;",
        {factory->NewStringFromStaticChars("number")}},
       {"var x = {}; eval('var x = 10;'); return typeof x;",
        {factory->NewStringFromStaticChars("number")}},
       {"'use strict'; var x = {}; eval('var x = 10;'); return typeof x;",
        {factory->NewStringFromStaticChars("object")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 
 TEST(BytecodeGraphBuilderEvalParams) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
 
   ExpectedSnippet<1> snippets[] = {
       {"var x = 10; return eval('x + p1;');",
        {handle(Smi::FromInt(30), isolate), handle(Smi::FromInt(20), isolate)}},
       {"var x = 10; eval('p1 = x;'); return p1;",
        {handle(Smi::FromInt(10), isolate), handle(Smi::FromInt(20), isolate)}},
       {"var a = 10;"
        "function inner() { return eval('a + p1;');}"
        "return inner();",
        {handle(Smi::FromInt(30), isolate), handle(Smi::FromInt(20), isolate)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1) { %s }\n%s(0);", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
@@ skipping 10 matching lines @@
        "function f() { add_global(); return z; }; f();",
        {handle(Smi::FromInt(33), isolate)}},
       {"function add_global() {\n"
        " eval('\"use strict\"; function f() { y = 33; };"
        "      try { f() } catch(e) {}');\n"
        "}\n"
        "function f() { add_global(); return typeof y; } f();",
        {factory->NewStringFromStaticChars("undefined")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     BytecodeGraphTester tester(isolate, zone, snippets[i].code_snippet);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 
 bool get_compare_result(Token::Value opcode, Handle<Object> lhs_value,
                         Handle<Object> rhs_value) {
@@ skipping 110 matching lines @@
         factory->NewNumberFromInt(10)}},
       {"return p2 in p1;",
        {factory->true_value(), BytecodeGraphTester::NewObject("({10 : 'val'})"),
         factory->NewNumberFromInt(10)}},
       {"return p2 in p1;",
        {factory->false_value(),
         BytecodeGraphTester::NewObject("({10 : 'val'})"),
         factory->NewNumberFromInt(1)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1, p2) { %s }\n%s({}, {});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>, Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0), snippets[i].parameter(1))
             .ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
@@ skipping 11 matching lines @@
       {"return p1 instanceof Object;",
        {factory->true_value(), BytecodeGraphTester::NewObject("({val : 10})")}},
       {"return p1 instanceof String;",
        {factory->false_value(), factory->NewStringFromStaticChars("string")}},
       {"var cons = function() {};"
        "var obj = new cons();"
        "return obj instanceof cons;",
        {factory->true_value(), factory->undefined_value()}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s(p1) { %s }\n%s({});", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 TEST(BytecodeGraphBuilderTryCatch) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
 
   ExpectedSnippet<0> snippets[] = {
       {"var a = 1; try { a = 2 } catch(e) { a = 3 }; return a;",
        {handle(Smi::FromInt(2), isolate)}},
       {"var a; try { undef.x } catch(e) { a = 2 }; return a;",
        {handle(Smi::FromInt(2), isolate)}},
       {"var a; try { throw 1 } catch(e) { a = e + 2 }; return a;",
        {handle(Smi::FromInt(3), isolate)}},
       {"var a; try { throw 1 } catch(e) { a = e + 2 };"
        "       try { throw a } catch(e) { a = e + 3 }; return a;",
        {handle(Smi::FromInt(6), isolate)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
@@ skipping 17 matching lines @@
       {"var a = 1; for (var i = 10; i < 20; i += 5) {"
        "  try { a = 2; continue; } finally { a = 3; }"
        "} return a + i;",
        {handle(Smi::FromInt(23), isolate)}},
       {"var a = 1; try { a = 2;"
        "  try { a = 3; throw 23; } finally { a = 4; }"
        "} catch(e) { a = a + e; } return a;",
        {handle(Smi::FromInt(27), isolate)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
 TEST(BytecodeGraphBuilderTryFinally2) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
 
   ExpectedSnippet<0, const char*> snippets[] = {
       {"var a = 1; try { a = 2; throw 23; } finally { a = 3 }; return a;",
        {"Uncaught 23"}},
       {"var a = 1; try { a = 2; throw 23; } finally { throw 42; };",
        {"Uncaught 42"}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     v8::Local<v8::String> message = tester.CheckThrowsReturnMessage()->Get();
     v8::Local<v8::String> expected_string = v8_str(snippets[i].return_value());
     CHECK(
         message->Equals(CcTest::isolate()->GetCurrentContext(), expected_string)
             .FromJust());
   }
 }
 
 TEST(BytecodeGraphBuilderThrow) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
 
   // TODO(mythria): Add more tests when real try-catch and deoptimization
   // information are supported.
   ExpectedSnippet<0, const char*> snippets[] = {
       {"throw undefined;", {"Uncaught undefined"}},
       {"throw 1;", {"Uncaught 1"}},
       {"throw 'Error';", {"Uncaught Error"}},
       {"throw 'Error1'; throw 'Error2'", {"Uncaught Error1"}},
       {"var a = true; if (a) { throw 'Error'; }", {"Uncaught Error"}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     v8::Local<v8::String> message = tester.CheckThrowsReturnMessage()->Get();
     v8::Local<v8::String> expected_string = v8_str(snippets[i].return_value());
     CHECK(
         message->Equals(CcTest::isolate()->GetCurrentContext(), expected_string)
             .FromJust());
@@ skipping 41 matching lines @@
        "     var innerMostFunc = function() {return x + innerFunc();};"
        "   }"
        "   x = 'inner_changed ';"
        " }"
        " return(innerMostFunc() + x);"
        "}"
        "f();",
        {factory->NewStringFromStaticChars("innermost inner_changed outer")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "%s", snippets[i].code_snippet);
 
     BytecodeGraphTester tester(isolate, zone, script.start(), "f");
     auto callable = tester.GetCallable<>("f");
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
@@ skipping 44 matching lines @@
       {"function testOuter(outerArg) {"
        " var outerVar = outerArg * 2;"
        " this.testinnerFunc = function testInner(innerArg) {"
        "   outerVar = outerVar + innerArg; return outerVar;"
        " }"
        "}"
        "var f = new testOuter(10).testinnerFunc;"
        "f(0);",
        {factory->NewNumberFromInt(24), factory->NewNumberFromInt(4)}}};
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "%s", snippets[i].code_snippet);
 
     BytecodeGraphTester tester(isolate, zone, script.start(), "*");
     auto callable = tester.GetCallable<Handle<Object>>("f");
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
@@ skipping 11 matching lines @@
       {"function f() {'use strict'; return arguments[0];}",
        {factory->undefined_value()}},
       {"function f(a) {'use strict'; return arguments[0];}",
        {factory->undefined_value()}},
       {"function f(...restArgs) {return restArgs[0];}",
        {factory->undefined_value()}},
       {"function f(a, ...restArgs) {return restArgs[0];}",
        {factory->undefined_value()}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "%s\n%s();", snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
@@ skipping 22 matching lines @@
         factory->NewNumberFromInt(2), factory->NewNumberFromInt(3)}},
       {"function f(a, b, c) {'use strict'; b = c; return arguments[1];}",
        {factory->NewNumberFromInt(2), factory->NewNumberFromInt(1),
         factory->NewNumberFromInt(2), factory->NewNumberFromInt(3)}},
       {"function inline_func(a, b) { return arguments[0] }"
        "function f(a, b, c) {return inline_func(b, c) + arguments[0];}",
        {factory->NewNumberFromInt(3), factory->NewNumberFromInt(1),
         factory->NewNumberFromInt(2), factory->NewNumberFromInt(30)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "%s\n%s();", snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable =
         tester.GetCallable<Handle<Object>, Handle<Object>, Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0), snippets[i].parameter(1),
                  snippets[i].parameter(2))
             .ToHandleChecked();
@@ skipping 22 matching lines @@
         factory->NewNumberFromInt(2), factory->NewNumberFromInt(3)}},
       {"function f(a, ...restArgs) { return arguments[0] + restArgs[1];}",
        {factory->NewNumberFromInt(4), factory->NewNumberFromInt(1),
         factory->NewNumberFromInt(2), factory->NewNumberFromInt(3)}},
       {"function inline_func(a, ...restArgs) { return restArgs[0] }"
        "function f(a, b, c) {return inline_func(b, c) + arguments[0];}",
        {factory->NewNumberFromInt(31), factory->NewNumberFromInt(1),
         factory->NewNumberFromInt(2), factory->NewNumberFromInt(30)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(1024);
     SNPrintF(script, "%s\n%s();", snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable =
         tester.GetCallable<Handle<Object>, Handle<Object>, Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0), snippets[i].parameter(1),
                  snippets[i].parameter(2))
             .ToHandleChecked();
@@ skipping 17 matching lines @@
        {factory->NewStringFromStaticChars("abbd")}},
       {"return /ab+d/.exec('cccabbdd')[1];", {factory->undefined_value()}},
       {"return /AbC/i.exec('ssaBC')[0];",
        {factory->NewStringFromStaticChars("aBC")}},
       {"return 'ssaBC'.match(/AbC/i)[0];",
        {factory->NewStringFromStaticChars("aBC")}},
       {"return 'ssaBCtAbC'.match(/(AbC)/gi)[1];",
        {factory->NewStringFromStaticChars("AbC")}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(4096);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
@@ skipping 19 matching lines @@
        REPEAT_256(SPACE, "a = 9.34;")
        "return [a, ++a, a + 2, a + 3][2];",
        {factory->NewHeapNumber(12.34)}},
       {"return [[1, 2, 3], ['a', 'b', 'c']][1][0];",
        {factory->NewStringFromStaticChars("a")}},
       {"var t = 't'; return [[t, t + 'est'], [1 + t]][0][1];",
        {factory->NewStringFromStaticChars("test")}},
       {"var t = 't'; return [[t, t + 'est'], [1 + t]][1][0];",
        {factory->NewStringFromStaticChars("1t")}}};
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(4096);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
@@ skipping 44 matching lines @@
        {factory->NewStringFromStaticChars("testing")}},
       {"var a = 'proto_str';\n"
        "var b = { [a]: 1, __proto__: { var : a } };\n"
        "return Object.getPrototypeOf(b).var",
        {factory->NewStringFromStaticChars("proto_str")}},
       {"var n = 'name';\n"
        "return { [n]: 'val', get a() { return 987 } }['a'];",
        {factory->NewNumberFromInt(987)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(4096);
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
@@ skipping 87 matching lines @@
        "   x = 4; d = 2;"
        "} else {\n"
        "   d = 3;\n"
        "}"
        "x = d;"
        "function f1() {x}"
        "return x + c;",
        {factory->NewNumberFromInt(5), factory->NewNumberFromInt(-1)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(2048);
     SNPrintF(script, "function %s(p1) { %s };\n%s(0);", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 10 matching lines @@
       {"return (p1 > 1) ? 1 : -1;",
        {factory->NewNumberFromInt(1), factory->NewNumberFromInt(2)}},
       {"return (p1 > 1) ? 1 : -1;",
        {factory->NewNumberFromInt(-1), factory->NewNumberFromInt(0)}},
       {"return (p1 > 50) ? 1 : ((p1 < 10) ? 10 : -10);",
        {factory->NewNumberFromInt(10), factory->NewNumberFromInt(2)}},
       {"return (p1 > 50) ? 1 : ((p1 < 10) ? 10 : -10);",
        {factory->NewNumberFromInt(-10), factory->NewNumberFromInt(20)}},
   };
 
-  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-  for (size_t i = 0; i < num_snippets; i++) {
+  for (size_t i = 0; i < arraysize(snippets); i++) {
     ScopedVector<char> script(2048);
     SNPrintF(script, "function %s(p1) { %s };\n%s(0);", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_value =
         callable(snippets[i].parameter(0)).ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
@@ skipping 522 matching lines @@
     SNPrintF(script, "function %s() { %s }\n%s();", kFunctionName,
              snippets[i].code_snippet, kFunctionName);
 
     BytecodeGraphTester tester(isolate, zone, script.start());
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*snippets[i].return_value()));
   }
 }
 
-
-TEST(JumpWithConstantsAndWideConstants) {
-  const int kStep = 19;
-  int start = 7;
-  for (int constants = start; constants < 256 + 3 * kStep; constants += kStep) {
+void TestJumpWithConstantsAndWideConstants(size_t shard) {
+  const int kStep = 46;
+  int start = static_cast<int>(7 + 17 * shard);
+  for (int constants = start; constants < 300; constants += kStep) {
     std::stringstream filler_os;
     // Generate a string that consumes constant pool entries and
     // spread out branch distances in script below.
     for (int i = 0; i < constants; i++) {
       filler_os << "var x_ = 'x_" << i << "';\n";
     }
     std::string filler(filler_os.str());
 
     std::stringstream script_os;
     script_os << "function " << kFunctionName << "(a) {\n";
     script_os << "  " << filler;
     script_os << "  for (var i = a; i < 2; i++) {\n";
     script_os << "  " << filler;
     script_os << "    if (i == 0) { " << filler << "i = 10; continue; }\n";
     script_os << "    else if (i == a) { " << filler << "i = 12; break; }\n";
     script_os << "    else { " << filler << " }\n";
     script_os << "  }\n";
     script_os << "  return i;\n";
     script_os << "}\n";
     script_os << kFunctionName << "(0);\n";
     std::string script(script_os.str());
 
     HandleAndZoneScope scope;
     auto isolate = scope.main_isolate();
     auto factory = isolate->factory();
     auto zone = scope.main_zone();
+    BytecodeGraphTester tester(isolate, zone, script.c_str());
+    auto callable = tester.GetCallable<Handle<Object>>();

[rmcilroy, 2016/02/16 14:06:56]

Thanks for spotting this.

     for (int a = 0; a < 3; a++) {
-      BytecodeGraphTester tester(isolate, zone, script.c_str());
-      auto callable = tester.GetCallable<Handle<Object>>();
       Handle<Object> return_val =
           callable(factory->NewNumberFromInt(a)).ToHandleChecked();
       static const int results[] = {11, 12, 2};
       CHECK_EQ(Handle<Smi>::cast(return_val)->value(), results[a]);
     }
   }
 }
 
+SHARD_TEST_BY_4(JumpWithConstantsAndWideConstants)
+
 TEST(BytecodeGraphBuilderDoExpressions) {
   bool old_flag = FLAG_harmony_do_expressions;
   FLAG_harmony_do_expressions = true;
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Zone* zone = scope.main_zone();
   Factory* factory = isolate->factory();
   ExpectedSnippet<0> snippets[] = {
       {"var a = do {}; return a;", {factory->undefined_value()}},
       {"var a = do { var x = 100; }; return a;", {factory->undefined_value()}},
@@ skipping 343 matching lines @@
 
   BytecodeGraphTester tester(isolate, zone, script.start());
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK(return_value->SameValue(*snippet.return_value()));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8