Track elements_kind transitions in KeyedStoreICs.

test/mjsunit/element-kind.js

 // Copyright 2011 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 165 matching lines @@
 %OptimizeFunctionOnNextCall(polymorphic);
 polymorphic(smis, element_kind.fast_smi_only_elements);
 polymorphic(strings, element_kind.fast_elements);
 polymorphic(doubles, support_smi_only_arrays
     ? element_kind.fast_double_elements
     : element_kind.fast_elements);
 
 // Crankshaft support for smi-only elements in dynamic array literals.
 function get(foo) { return foo; }  // Used to generate dynamic values.
 
-//function crankshaft_test(expected_kind) {
 function crankshaft_test() {
   var a = [get(1), get(2), get(3)];
   assertKind(element_kind.fast_smi_only_elements, a);
   var b = [get(1), get(2), get("three")];
   assertKind(element_kind.fast_elements, b);
   var c = [get(1), get(2), get(3.5)];
   // The full code generator doesn't support conversion to fast_double_elements
   // yet. Crankshaft does, but only with --smi-only-arrays support.
   if ((%GetOptimizationStatus(crankshaft_test) & 1) &&
       support_smi_only_arrays) {
     assertKind(element_kind.fast_double_elements, c);
   } else {
     assertKind(element_kind.fast_elements, c);
   }
 }
 for (var i = 0; i < 3; i++) {
   crankshaft_test();
 }
 %OptimizeFunctionOnNextCall(crankshaft_test);
 crankshaft_test();
+
+// Elements_kind transitions for arrays.
+
+// A map can have three different elements_kind transitions: SMI->DOUBLE,
+// DOUBLE->OBJECT, and SMI->OBJECT. No matter in which order these three are
+// created, they must always end up with the same FAST map.
+// Preparation: create one pair of identical objects for each case.
+var a = [1, 2, 3];
+var b = [1, 2, 3];
+assertTrue(%HaveSameMap(a, b));
+assertKind(element_kind.fast_smi_only_elements, a);
+var c = [1, 2, 3];
+c["case2"] = true;
+var d = [1, 2, 3];
+d["case2"] = true;
+assertTrue(%HaveSameMap(c, d));
+assertFalse(%HaveSameMap(a, c));
+assertKind(element_kind.fast_smi_only_elements, c);
+var e = [1, 2, 3];
+e["case3"] = true;
+var f = [1, 2, 3];
+f["case3"] = true;
+assertTrue(%HaveSameMap(e, f));
+assertFalse(%HaveSameMap(a, e));
+assertFalse(%HaveSameMap(c, e));
+assertKind(element_kind.fast_smi_only_elements, e);
+// Case 1: SMI->DOUBLE, DOUBLE->OBJECT, SMI->OBJECT.
+a[0] = 1.5;
+assertKind(element_kind.fast_double_elements, a);
+a[0] = "foo";
+assertKind(element_kind.fast_elements, a);
+b[0] = "bar";
+assertTrue(%HaveSameMap(a, b));
+// Case 2: SMI->DOUBLE, SMI->OBJECT, DOUBLE->OBJECT.
+c[0] = 1.5;
+assertKind(element_kind.fast_double_elements, c);
+assertFalse(%HaveSameMap(c, d));
+d[0] = "foo";
+assertKind(element_kind.fast_elements, d);
+assertFalse(%HaveSameMap(c, d));
+c[0] = "bar";
+assertTrue(%HaveSameMap(c, d));
+// Case 3: SMI->OBJECT, SMI->DOUBLE, DOUBLE->OBJECT.
+e[0] = "foo";
+assertKind(element_kind.fast_elements, e);
+assertFalse(%HaveSameMap(e, f));
+f[0] = 1.5;
+assertKind(element_kind.fast_double_elements, f);
+assertFalse(%HaveSameMap(e, f));
+f[0] = "bar";
+assertKind(element_kind.fast_elements, f);
+assertTrue(%HaveSameMap(e, f));