Basic array capacity feedback via allocation sites.

test/mjsunit/array-constructor-feedback.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 44 matching lines @@
 
 function isHoley(obj) {
   if (%HasFastHoleyElements(obj)) return true;
   return false;
 }
 
 function assertKind(expected, obj, name_opt) {
   assertEquals(expected, getKind(obj), name_opt);
 }
 
+
 // Test: If a call site goes megamorphic, it retains the ability to
 // use allocation site feedback (if FLAG_allocation_site_pretenuring
 // is on).
 (function() {
   function bar(t, len) {
     return new t(len);
   }
 
   a = bar(Array, 10);
   a[0] = 3.5;
@@ skipping 135 matching lines @@
   a = bar(100);
   assertTrue(isHoley(a));
   a = bar(0);
   assertOptimized(bar);
   // Crankshafted functions don't use mementos, so feedback still
   // indicates a packed array is desired. (unless --nocrankshaft is in use).
   if (4 != %GetOptimizationStatus(bar)) {
     assertFalse(isHoley(a));
   }
 })();
+
+
+// Test: verify that elements capacity feedback works
+(function() {
+  // It works for optimized functions with a no-argument array call.
+  function foo() { return new Array(); }
+  a = foo();
+  a.push(1, 2, 3, 4, 5, 6);
+  assertEquals(25, %GetElementsCapacity(a));
+  %OptimizeFunctionOnNextCall(foo);
+  b = foo();
+  assertEquals(25, %GetElementsCapacity(b));
+
+  // It works for optimized functions with a constant argument array call.
+  function bar() { return new Array(1); }
+  a = bar();
+  a.push(1, 2, 3, 4, 5, 6);
+  assertEquals(26, %GetElementsCapacity(a));
+  %OptimizeFunctionOnNextCall(bar);
+  b = bar();
+  assertEquals(26, %GetElementsCapacity(b));
+
+  // It doesn't work for functions with a non-constant length for array.
+  function nonconst(l) { return new Array(l); }
+  a = nonconst(1);
+  a.push(1, 2, 3, 4, 5, 6);
+  assertEquals(26, %GetElementsCapacity(a));
+  %OptimizeFunctionOnNextCall(nonconst);
+  b = nonconst(3);
+  assertEquals(3, %GetElementsCapacity(b));
+
+  // It doesn't work for multiple arguments to the array constructor.
+  function some_args() { return new Array(1, 2, 3); }
+  a = some_args();
+  a.push(1, 2, 3, 4, 5, 6);
+  assertEquals(29, %GetElementsCapacity(a));
+  %OptimizeFunctionOnNextCall(some_args);
+  b = some_args();
+  assertEquals(3, %GetElementsCapacity(b));
+
+  // It doesn't work for literals.
+  function with_literal() { var a = [1,2]; return a; }
+  a = with_literal();
+  a.push(1, 2, 3, 4, 5, 6);
+  assertEquals(28, %GetElementsCapacity(a));
+  %OptimizeFunctionOnNextCall(with_literal);
+  b = with_literal();
+  assertEquals(0, %GetElementsCapacity(b));
+})();