HCheckFunction is needed to protect new array constructors in

test/mjsunit/array-constructor-feedback.js

-// Copyright 2013 the V8 project authors. All rights reserved.
+// 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
 //       with the distribution.
@@ skipping 18 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',
+  external_unsigned_int    :  'external unsigned int elements',
+  external_float           :  'external float elements',
+  external_double          :  'external double elements',
+  external_pixel           :  'external pixel elements'
+}
+
+function getKind(obj) {
+  if (%HasFastSmiElements(obj)) return elements_kind.fast_smi_only;
+  if (%HasFastObjectElements(obj)) return elements_kind.fast;
+  if (%HasFastDoubleElements(obj)) return elements_kind.fast_double;
+  if (%HasDictionaryElements(obj)) return elements_kind.dictionary;
+}
+
 function isHoley(obj) {
   if (%HasFastHoleyElements(obj)) return true;
   return false;
 }
 
-function assertHoley(obj, name_opt) {
-  assertEquals(true, isHoley(obj), name_opt);
+function assertKind(expected, obj, name_opt) {
+  if (!support_smi_only_arrays &&
+      expected == elements_kind.fast_smi_only) {
+    expected = elements_kind.fast;
+  }
+  assertEquals(expected, getKind(obj), name_opt);
 }
 
-function assertNotHoley(obj, name_opt) {
-  assertEquals(false, isHoley(obj), name_opt);
-}
-
-if (support_smi_only_arrays) {
-  function create_array(arg) {
-    return new Array(arg);
+if (support_smi_only_arrays && optimize_constructed_arrays) {
+  function bar0(t) {
+    return new t();
   }
 
-  obj = create_array(0);
-  assertNotHoley(obj);
-  create_array(0);
-  %OptimizeFunctionOnNextCall(create_array);
-  obj = create_array(10);
-  assertHoley(obj);
+  a = bar0(Array);
+  a[0] = 3.5;
+  b = bar0(Array);
+  assertKind(elements_kind.fast_double, b);
+  %OptimizeFunctionOnNextCall(bar0);
+  b = bar0(Array);
+  assertKind(elements_kind.fast_double, b);
+  assertTrue(2 != %GetOptimizationStatus(bar0));
+  // bar0 should deopt
+  b = bar0(Object);
+  assertTrue(1 != %GetOptimizationStatus(bar0));
 }
-
-// The code below would assert in debug or crash in release
-function f(length) {
-  return new Array(length)
-}
-
-f(0);
-f(0);
-%OptimizeFunctionOnNextCall(f);
-var a = f(10);
-
-function g(a) {
-  return a[0];
-}
-
-var b = [0];
-g(b);
-g(b);
-assertEquals(undefined, g(a));