Optimize call sites that only ever have a single elements transition

test/mjsunit/elements-kind.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 25 matching lines @@
 
 support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6,7,8));
 
 if (support_smi_only_arrays) {
   print("Tests include smi-only arrays.");
 } else {
   print("Tests do NOT include smi-only arrays.");
 }
 
 var elements_kind = {
+  any                      :  'ignoreme',
   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',
@@ skipping 32 matching lines @@
   }
   if (%HasExternalDoubleElements(obj)) {
     return elements_kind.external_double;
   }
   if (%HasExternalPixelElements(obj)) {
     return elements_kind.external_pixel;
   }
 }
 
 function assertKind(expected, obj, name_opt) {
+  if (expected == elements_kind.any)
+    return;
   if (!support_smi_only_arrays &&
       expected == elements_kind.fast_smi_only) {
     expected = elements_kind.fast;
   }
   assertEquals(expected, getKind(obj), name_opt);
 }
 
 var me = {};
 assertKind(elements_kind.fast, me);
 me.dance = 0xD15C0;
@@ skipping 76 matching lines @@
   }
 
   // Test crankshafted transition SMI->DOUBLE.
   function convert_to_double(array) {
     array[1] = 2.5;
     assertKind(elements_kind.fast_double, array);
     assertEquals(2.5, array[1]);
   }
   var smis = construct_smis();
   for (var i = 0; i < 3; i++) convert_to_double(smis);
+  smis = construct_smis();
+  for (var i = 0; i < 3; i++) convert_to_double(smis);
   %OptimizeFunctionOnNextCall(convert_to_double);
   smis = construct_smis();
   convert_to_double(smis);
+  assertTrue(2 != %GetOptimizationStatus(convert_to_double));
   // Test crankshafted transitions SMI->FAST and DOUBLE->FAST.
   function convert_to_fast(array) {
     array[1] = "two";
     assertKind(elements_kind.fast, array);
     assertEquals("two", array[1]);
   }
   smis = construct_smis();
   for (var i = 0; i < 3; i++) convert_to_fast(smis);
   var doubles = construct_doubles();
   for (var i = 0; i < 3; i++) convert_to_fast(doubles);
   smis = construct_smis();
+  for (var i = 0; i < 3; i++) convert_to_fast(smis);
+  smis = construct_smis();
   doubles = construct_doubles();
   %OptimizeFunctionOnNextCall(convert_to_fast);
   convert_to_fast(smis);
   convert_to_fast(doubles);
+  assertTrue(2 != %GetOptimizationStatus(convert_to_fast));
   // Test transition chain SMI->DOUBLE->FAST (crankshafted function will
   // transition to FAST directly).
   function convert_mixed(array, value, kind) {
     array[1] = value;
     assertKind(kind, array);
     assertEquals(value, array[1]);
   }
   smis = construct_smis();
   for (var i = 0; i < 3; i++) {
     convert_mixed(smis, 1.5, elements_kind.fast_double);
   }
   doubles = construct_doubles();
   for (var i = 0; i < 3; i++) {
     convert_mixed(doubles, "three", elements_kind.fast);
   }
   smis = construct_smis();
+  for (var i = 0; i < 3; i++) {
+    convert_mixed(smis, 1.5, elements_kind.any);
+  }
+  smis = construct_smis();
   doubles = construct_doubles();
   %OptimizeFunctionOnNextCall(convert_mixed);
   convert_mixed(smis, 1, elements_kind.fast);
   convert_mixed(doubles, 1, elements_kind.fast);
+  assertTrue(2 != %GetOptimizationStatus(convert_mixed));
   assertTrue(%HaveSameMap(smis, doubles));
 }
 
 // Crankshaft support for smi-only elements in dynamic array literals.
 function get(foo) { return foo; }  // Used to generate dynamic values.
 
 function crankshaft_test() {
   if (support_smi_only_arrays) {
     var a1 = [get(1), get(2), get(3)];
     assertKind(elements_kind.fast_smi_only, a1);
@@ skipping 95 matching lines @@
   var a = ["foo", "bar"];
   assertKind(elements_kind.fast, a);
   var b = a.splice(0, 1);
   assertKind(elements_kind.fast, b);
   var c = a.slice(0, 1);
   assertKind(elements_kind.fast, c);
 }
 
 // Throw away type information in the ICs for next stress run.
 gc();