Add a premonomorphic state to the call target cache.

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 71 matching lines @@
 
 if (support_smi_only_arrays) {
 
   // Test: If a call site goes megamorphic, it loses the ability to
   // use allocation site feedback.
   (function() {
     function bar(t, len) {
       return new t(len);
     }
 
+    bar(Array, 10);  // Skip premonomorphic state.
     a = bar(Array, 10);
     a[0] = 3.5;
     b = bar(Array, 1);
     assertKind(elements_kind.fast_double, b);
     c = bar(Object, 3);
     b = bar(Array, 10);
     assertKind(elements_kind.fast_smi_only, b);
     b[0] = 3.5;
     c = bar(Array, 10);
     assertKind(elements_kind.fast_smi_only, c);
   })();
 
 
   // Test: ensure that crankshafted array constructor sites are deopted
   // if another function is used.
   (function() {
     function bar0(t) {
       return new t();
     }
+
+    bar0(Array);  // Skip premonomorphic state.
     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);
     assertOptimized(bar0);
     // bar0 should deopt
     b = bar0(Object);
@@ skipping 11 matching lines @@
     assertKind(elements_kind.fast_smi_only, c);
   })();
 
 
   // Test: Ensure that inlined array calls in crankshaft learn from deopts
   // based on the move to a dictionary for the array.
   (function() {
     function bar(len) {
       return new Array(len);
     }
+
+    bar(10);  // Skip premonomorphic state.
     a = bar(10);
     a[0] = "a string";
     a = bar(10);
     assertKind(elements_kind.fast, a);
     %OptimizeFunctionOnNextCall(bar);
     a = bar(10);
     assertKind(elements_kind.fast, a);
     assertOptimized(bar);
     // bar should deopt because the length is too large.
     a = bar(100000);
@@ skipping 31 matching lines @@
   })();
 
 
   // Test: When a method with array constructor is crankshafted, the type
   // feedback for elements kind is baked in. Verify that transitions don't
   // change it anymore
   (function() {
     function bar() {
       return new Array();
     }
+
+    bar();  // Skip premonomorphic state.
     a = bar();
     bar();
     %OptimizeFunctionOnNextCall(bar);
     b = bar();
     // This only makes sense to test if we allow crankshafting
     if (4 != %GetOptimizationStatus(bar)) {
       assertOptimized(bar);
       %DebugPrint(3);
       b[0] = 3.5;
       c = bar();
@@ skipping 40 matching lines @@
     // Try again
     %OptimizeFunctionOnNextCall(bar);
     a = bar(100);
     assertOptimized(bar);
     assertTrue(isHoley(a));
     a = bar(0);
     assertOptimized(bar);
     assertTrue(isHoley(a));
   })();
 }