Removed flag optimize-constructed-arrays.

test/mjsunit/allocation-site-info.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 19 matching lines @@
 
 // Test element kind of objects.
 // Since --smi-only-arrays affects builtins, its default setting at compile
 // time sticks if built with snapshot.  If --smi-only-arrays is deactivated
 // by default, only a no-snapshot build actually has smi-only arrays enabled
 // in this test case.  Depending on whether smi-only arrays are actually
 // enabled, this test takes the appropriate code path to check smi-only arrays.
 
 // support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6,7,8));
 support_smi_only_arrays = true;
-optimize_constructed_arrays = true;
 
 if (support_smi_only_arrays) {
   print("Tests include smi-only arrays.");
 } else {
   print("Tests do NOT include smi-only arrays.");
 }
 
-if (optimize_constructed_arrays) {
-  print("Tests include constructed array optimizations.");
-} else {
-  print("Tests do NOT include constructed array optimizations.");
-}
-
 var elements_kind = {
   fast_smi_only            :  'fast smi only elements',
   fast                     :  'fast elements',
   fast_double              :  'fast double elements',
   dictionary               :  'dictionary elements',
   external_byte            :  'external byte elements',
   external_unsigned_byte   :  'external unsigned byte elements',
   external_short           :  'external short elements',
   external_unsigned_short  :  'external unsigned short elements',
   external_int             :  'external int elements',
@@ skipping 116 matching lines @@
 
   obj = fastliteralcase_smifast(1);
   assertKind(elements_kind.fast_smi_only, obj);
   obj = fastliteralcase_smifast("carter");
   assertKind(elements_kind.fast, obj);
   obj = fastliteralcase_smifast(2);
   // TODO(hpayer): bring the following assert back as soon as allocation
   // sites work again for fast literals
   //assertKind(elements_kind.fast, obj);
 
-  if (optimize_constructed_arrays) {
-    function newarraycase_smidouble(value) {
-      var a = new Array();
-      a[0] = value;
-      return a;
-    }
+  function newarraycase_smidouble(value) {
+    var a = new Array();
+    a[0] = value;
+    return a;
+  }
 
-    // Case: new Array() as allocation site, smi->double
-    obj = newarraycase_smidouble(1);
-    assertKind(elements_kind.fast_smi_only, obj);
-    obj = newarraycase_smidouble(1.5);
-    assertKind(elements_kind.fast_double, obj);
-    obj = newarraycase_smidouble(2);
-    assertKind(elements_kind.fast_double, obj);
+  // Case: new Array() as allocation site, smi->double
+  obj = newarraycase_smidouble(1);
+  assertKind(elements_kind.fast_smi_only, obj);
+  obj = newarraycase_smidouble(1.5);
+  assertKind(elements_kind.fast_double, obj);
+  obj = newarraycase_smidouble(2);
+  assertKind(elements_kind.fast_double, obj);
 
-    function newarraycase_smiobj(value) {
-      var a = new Array();
-      a[0] = value;
-      return a;
-    }
+  function newarraycase_smiobj(value) {
+    var a = new Array();
+    a[0] = value;
+    return a;
+  }
 
-    // Case: new Array() as allocation site, smi->fast
-    obj = newarraycase_smiobj(1);
-    assertKind(elements_kind.fast_smi_only, obj);
-    obj = newarraycase_smiobj("gloria");
-    assertKind(elements_kind.fast, obj);
-    obj = newarraycase_smiobj(2);
-    assertKind(elements_kind.fast, obj);
+  // Case: new Array() as allocation site, smi->fast
+  obj = newarraycase_smiobj(1);
+  assertKind(elements_kind.fast_smi_only, obj);
+  obj = newarraycase_smiobj("gloria");
+  assertKind(elements_kind.fast, obj);
+  obj = newarraycase_smiobj(2);
+  assertKind(elements_kind.fast, obj);
 
-    function newarraycase_length_smidouble(value) {
-      var a = new Array(3);
-      a[0] = value;
-      return a;
-    }
+  function newarraycase_length_smidouble(value) {
+    var a = new Array(3);
+    a[0] = value;
+    return a;
+  }
 
-    // Case: new Array(length) as allocation site
-    obj = newarraycase_length_smidouble(1);
-    assertKind(elements_kind.fast_smi_only, obj);
-    obj = newarraycase_length_smidouble(1.5);
-    assertKind(elements_kind.fast_double, obj);
-    obj = newarraycase_length_smidouble(2);
-    assertKind(elements_kind.fast_double, obj);
+  // Case: new Array(length) as allocation site
+  obj = newarraycase_length_smidouble(1);
+  assertKind(elements_kind.fast_smi_only, obj);
+  obj = newarraycase_length_smidouble(1.5);
+  assertKind(elements_kind.fast_double, obj);
+  obj = newarraycase_length_smidouble(2);
+  assertKind(elements_kind.fast_double, obj);
 
-    // Try to continue the transition to fast object, but
-    // we will not pretransition from double->fast, because
-    // it may hurt performance ("poisoning").
-    obj = newarraycase_length_smidouble("coates");
-    assertKind(elements_kind.fast, obj);
-    obj = newarraycase_length_smidouble(2.5);
-    // However, because of optimistic transitions, we will
-    // transition to the most general kind of elements kind found,
-    // therefore I can't count on this assert yet.
-    // assertKind(elements_kind.fast_double, obj);
+  // Try to continue the transition to fast object, but
+  // we will not pretransition from double->fast, because
+  // it may hurt performance ("poisoning").
+  obj = newarraycase_length_smidouble("coates");
+  assertKind(elements_kind.fast, obj);
+  obj = newarraycase_length_smidouble(2.5);
+  // However, because of optimistic transitions, we will
+  // transition to the most general kind of elements kind found,
+  // therefore I can't count on this assert yet.
+  // assertKind(elements_kind.fast_double, obj);
 
-    function newarraycase_length_smiobj(value) {
-      var a = new Array(3);
-      a[0] = value;
-      return a;
-    }
+  function newarraycase_length_smiobj(value) {
+    var a = new Array(3);
+    a[0] = value;
+    return a;
+  }
 
-    // Case: new Array(<length>) as allocation site, smi->fast
-    obj = newarraycase_length_smiobj(1);
-    assertKind(elements_kind.fast_smi_only, obj);
-    obj = newarraycase_length_smiobj("gloria");
-    assertKind(elements_kind.fast, obj);
-    obj = newarraycase_length_smiobj(2);
-    assertKind(elements_kind.fast, obj);
+  // Case: new Array(<length>) as allocation site, smi->fast
+  obj = newarraycase_length_smiobj(1);
+  assertKind(elements_kind.fast_smi_only, obj);
+  obj = newarraycase_length_smiobj("gloria");
+  assertKind(elements_kind.fast, obj);
+  obj = newarraycase_length_smiobj(2);
+  assertKind(elements_kind.fast, obj);
 
-    function newarraycase_list_smidouble(value) {
-      var a = new Array(1, 2, 3);
-      a[0] = value;
-      return a;
-    }
+  function newarraycase_list_smidouble(value) {
+    var a = new Array(1, 2, 3);
+    a[0] = value;
+    return a;
+  }
 
-    obj = newarraycase_list_smidouble(1);
-    assertKind(elements_kind.fast_smi_only, obj);
-    obj = newarraycase_list_smidouble(1.5);
-    assertKind(elements_kind.fast_double, obj);
-    obj = newarraycase_list_smidouble(2);
-    assertKind(elements_kind.fast_double, obj);
+  obj = newarraycase_list_smidouble(1);
+  assertKind(elements_kind.fast_smi_only, obj);
+  obj = newarraycase_list_smidouble(1.5);
+  assertKind(elements_kind.fast_double, obj);
+  obj = newarraycase_list_smidouble(2);
+  assertKind(elements_kind.fast_double, obj);
 
-    function newarraycase_list_smiobj(value) {
-      var a = new Array(4, 5, 6);
-      a[0] = value;
-      return a;
-    }
+  function newarraycase_list_smiobj(value) {
+    var a = new Array(4, 5, 6);
+    a[0] = value;
+    return a;
+  }
 
-    obj = newarraycase_list_smiobj(1);
-    assertKind(elements_kind.fast_smi_only, obj);
-    obj = newarraycase_list_smiobj("coates");
-    assertKind(elements_kind.fast, obj);
-    obj = newarraycase_list_smiobj(2);
-    assertKind(elements_kind.fast, obj);
+  obj = newarraycase_list_smiobj(1);
+  assertKind(elements_kind.fast_smi_only, obj);
+  obj = newarraycase_list_smiobj("coates");
+  assertKind(elements_kind.fast, obj);
+  obj = newarraycase_list_smiobj(2);
+  assertKind(elements_kind.fast, obj);
 
-    function newarraycase_onearg(len, value) {
-      var a = new Array(len);
-      a[0] = value;
-      return a;
-    }
+  function newarraycase_onearg(len, value) {
+    var a = new Array(len);
+    a[0] = value;
+    return a;
+  }
 
-    obj = newarraycase_onearg(5, 3.5);
-    assertKind(elements_kind.fast_double, obj);
-    obj = newarraycase_onearg(10, 5);
-    assertKind(elements_kind.fast_double, obj);
-    obj = newarraycase_onearg(0, 5);
-    assertKind(elements_kind.fast_double, obj);
-    // Now pass a length that forces the dictionary path.
-    obj = newarraycase_onearg(100000, 5);
-    assertKind(elements_kind.dictionary, obj);
-    assertTrue(obj.length == 100000);
+  obj = newarraycase_onearg(5, 3.5);
+  assertKind(elements_kind.fast_double, obj);
+  obj = newarraycase_onearg(10, 5);
+  assertKind(elements_kind.fast_double, obj);
+  obj = newarraycase_onearg(0, 5);
+  assertKind(elements_kind.fast_double, obj);
+  // Now pass a length that forces the dictionary path.
+  obj = newarraycase_onearg(100000, 5);
+  assertKind(elements_kind.dictionary, obj);
+  assertTrue(obj.length == 100000);
 
-    // Verify that cross context calls work
-    var realmA = Realm.current();
-    var realmB = Realm.create();
-    assertEquals(0, realmA);
-    assertEquals(1, realmB);
+  // Verify that cross context calls work
+  var realmA = Realm.current();
+  var realmB = Realm.create();
+  assertEquals(0, realmA);
+  assertEquals(1, realmB);
 
-    function instanceof_check(type) {
-      assertTrue(new type() instanceof type);
-      assertTrue(new type(5) instanceof type);
-      assertTrue(new type(1,2,3) instanceof type);
-    }
+  function instanceof_check(type) {
+    assertTrue(new type() instanceof type);
+    assertTrue(new type(5) instanceof type);
+    assertTrue(new type(1,2,3) instanceof type);
+  }
 
-    var realmBArray = Realm.eval(realmB, "Array");
-    instanceof_check(Array);
-    instanceof_check(realmBArray);
+  var realmBArray = Realm.eval(realmB, "Array");
+  instanceof_check(Array);
+  instanceof_check(realmBArray);
     %OptimizeFunctionOnNextCall(instanceof_check);
-    instanceof_check(Array);
-    assertTrue(2 != %GetOptimizationStatus(instanceof_check));
-    instanceof_check(realmBArray);
-    assertTrue(1 != %GetOptimizationStatus(instanceof_check));
-  }
+  instanceof_check(Array);
+  assertTrue(2 != %GetOptimizationStatus(instanceof_check));
+  instanceof_check(realmBArray);
+  assertTrue(1 != %GetOptimizationStatus(instanceof_check));
 }