Add a premonomorphic state to the call target cache.

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 110 matching lines @@
     literal[0] = value;
     return literal;
   }
 
   function get_standard_literal() {
     var literal = [1, 2, 3];
     return literal;
   }
 
   // Case: [1,2,3] as allocation site
+  get_standard_literal();  // Skip premonomorphic state.
   obj = fastliteralcase(get_standard_literal(), 1);
   assertKind(elements_kind.fast_smi_only, obj);
   obj = fastliteralcase(get_standard_literal(), 1.5);
   assertKind(elements_kind.fast_double, obj);
   obj = fastliteralcase(get_standard_literal(), 2);
   assertKind(elements_kind.fast_double, obj);
 
   // The test below is in a loop because arrays that live
   // at global scope without the chance of being recreated
   // don't have allocation site information attached.
@@ skipping 21 matching lines @@
   get_standard_literal();
   obj = get_standard_literal();
   assertKind(elements_kind.fast, obj);
 
   function fastliteralcase_smifast(value) {
     var literal = [1, 2, 3, 4];
     literal[0] = value;
     return literal;
   }
 
+  fastliteralcase_smifast(1);  // Skip premonomorphic state.
   obj = fastliteralcase_smifast(1);
   assertKind(elements_kind.fast_smi_only, obj);
   obj = fastliteralcase_smifast("carter");
   assertKind(elements_kind.fast, obj);
   obj = fastliteralcase_smifast(2);
   assertKind(elements_kind.fast, obj);
 
   // Case: make sure transitions from packed to holey are tracked
   function fastliteralcase_smiholey(index, value) {
     var literal = [1, 2, 3, 4];
     literal[index] = value;
     return literal;
   }
 
+  fastliteralcase_smiholey(5, 1);  // Skip premonomorphic state.
   obj = fastliteralcase_smiholey(5, 1);
   assertKind(elements_kind.fast_smi_only, obj);
   assertHoley(obj);
   obj = fastliteralcase_smiholey(0, 1);
   assertKind(elements_kind.fast_smi_only, obj);
   assertHoley(obj);
 
   function newarraycase_smidouble(value) {
     var a = new Array();
     a[0] = value;
     return a;
   }
 
   // Case: new Array() as allocation site, smi->double
+  newarraycase_smidouble(1);  // Skip premonomorphic state.
   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;
   }
 
   // Case: new Array() as allocation site, smi->fast
+  newarraycase_smiobj(1);  // Skip premonomorphic state.
   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;
   }
 
   // Case: new Array(length) as allocation site
+  newarraycase_length_smidouble(1);  // Skip premonomorphic state.
   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. This won't work for
   // constructed arrays because constructor dispatch is done on the
   // elements kind, and a DOUBLE array constructor won't create an allocation
   // memento.
   obj = newarraycase_length_smidouble("coates");
   assertKind(elements_kind.fast, obj);
   obj = newarraycase_length_smidouble(2);
   assertKind(elements_kind.fast_double, obj);
 
   function newarraycase_length_smiobj(value) {
     var a = new Array(3);
     a[0] = value;
     return a;
   }
 
   // Case: new Array(<length>) as allocation site, smi->fast
+  newarraycase_length_smiobj(1);  // Skip premonomorphic state.
   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;
   }
 
+  newarraycase_list_smidouble(1);  // Skip premonomorphic state.
   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;
   }
 
+  newarraycase_list_smiobj(1);  // Skip premonomorphic state.
   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);
 
   // Case: array constructor calls with out of date feedback.
   // The boilerplate should incorporate all feedback, but the input array
   // should be minimally transitioned based on immediate need.
   (function() {
     function foo(i) {
       // We have two cases, one for literals one for constructed arrays.
       var a = (i == 0)
         ? [1, 2, 3]
         : new Array(1, 2, 3);
       return a;
     }
 
+    foo(0); foo(1);  // Skip premonomorphic state.
     for (i = 0; i < 2; i++) {
       a = foo(i);
       b = foo(i);
       b[5] = 1;  // boilerplate goes holey
       assertHoley(foo(i));
       a[0] = 3.5;  // boilerplate goes holey double
       assertKind(elements_kind.fast_double, a);
       assertNotHoley(a);
       c = foo(i);
       assertKind(elements_kind.fast_double, c);
       assertHoley(c);
     }
   })();
 
   function newarraycase_onearg(len, value) {
     var a = new Array(len);
     a[0] = value;
     return a;
   }
 
+  newarraycase_onearg(5, 3.5);  // Skip premonomorphic state.
   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);
@@ skipping 55 matching lines @@
 
   // Case: make sure nested arrays benefit from allocation site feedback as
   // well.
   (function() {
     // Make sure we handle nested arrays
    function get_nested_literal() {
      var literal = [[1,2,3,4], [2], [3]];
      return literal;
    }
 
+   get_nested_literal();  // Skip premonomorphic state.
    obj = get_nested_literal();
    assertKind(elements_kind.fast, obj);
    obj[0][0] = 3.5;
    obj[2][0] = "hello";
    obj = get_nested_literal();
    assertKind(elements_kind.fast_double, obj[0]);
    assertKind(elements_kind.fast_smi_only, obj[1]);
    assertKind(elements_kind.fast, obj[2]);
 
    // A more complex nested literal case.
    function get_deep_nested_literal() {
      var literal = [[1], [[2], "hello"], 3, [4]];
      return literal;
    }
 
+   get_deep_nested_literal();  // Skip premonomorphic state.
    obj = get_deep_nested_literal();
    assertKind(elements_kind.fast_smi_only, obj[1][0]);
    obj[0][0] = 3.5;
    obj[1][0][0] = "goodbye";
    assertKind(elements_kind.fast_double, obj[0]);
    assertKind(elements_kind.fast, obj[1][0]);
 
    obj = get_deep_nested_literal();
    assertKind(elements_kind.fast_double, obj[0]);
    assertKind(elements_kind.fast, obj[1][0]);
   })();
 
 
   // Make sure object literals with array fields benefit from the type feedback
   // that allocation mementos provide.
   (function() {
     // A literal in an object
     function get_object_literal() {
       var literal = {
         array: [1,2,3],
         data: 3.5
       };
       return literal;
     }
 
+    get_object_literal();  // Skip premonomorphic state.
     obj = get_object_literal();
     assertKind(elements_kind.fast_smi_only, obj.array);
     obj.array[1] = 3.5;
     assertKind(elements_kind.fast_double, obj.array);
     obj = get_object_literal();
     assertKind(elements_kind.fast_double, obj.array);
 
     function get_nested_object_literal() {
       var literal = {
         array: [[1],[2],[3]],
         data: 3.5
       };
       return literal;
     }
 
+    get_nested_object_literal();  // Skip premonomorphic state.
     obj = get_nested_object_literal();
     assertKind(elements_kind.fast, obj.array);
     assertKind(elements_kind.fast_smi_only, obj.array[1]);
     obj.array[1][0] = 3.5;
     assertKind(elements_kind.fast_double, obj.array[1]);
     obj = get_nested_object_literal();
     assertKind(elements_kind.fast_double, obj.array[1]);
 
     %OptimizeFunctionOnNextCall(get_nested_object_literal);
     get_nested_object_literal();
     obj = get_nested_object_literal();
     assertKind(elements_kind.fast_double, obj.array[1]);
 
     // Make sure we handle nested arrays
     function get_nested_literal() {
       var literal = [[1,2,3,4], [2], [3]];
       return literal;
     }
 
+    get_nested_literal();  // Skip premonomorphic state.
     obj = get_nested_literal();
     assertKind(elements_kind.fast, obj);
     obj[0][0] = 3.5;
     obj[2][0] = "hello";
     obj = get_nested_literal();
     assertKind(elements_kind.fast_double, obj[0]);
     assertKind(elements_kind.fast_smi_only, obj[1]);
     assertKind(elements_kind.fast, obj[2]);
 
     // A more complex nested literal case.
     function get_deep_nested_literal() {
       var literal = [[1], [[2], "hello"], 3, [4]];
       return literal;
     }
 
+    get_deep_nested_literal();  // Skip premonomorphic state.
     obj = get_deep_nested_literal();
     assertKind(elements_kind.fast_smi_only, obj[1][0]);
     obj[0][0] = 3.5;
     obj[1][0][0] = "goodbye";
     assertKind(elements_kind.fast_double, obj[0]);
     assertKind(elements_kind.fast, obj[1][0]);
 
     obj = get_deep_nested_literal();
     assertKind(elements_kind.fast_double, obj[0]);
     assertKind(elements_kind.fast, obj[1][0]);
   })();
 }