Force transition to FAST_ELEMENTS on out-of-bounds KeyedLoads.

test/mjsunit/unbox-double-arrays.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 59 matching lines @@
   }
 
   // Multiple versions of the test function makes sure that IC/Crankshaft state
   // doesn't get reused.
   function test_various_loads(a, value_5, value_6, value_7) {
     assertTrue(%HasFastDoubleElements(a));
     assertEquals(value_5, a[5]);
     assertEquals(value_6, a[6]);
     assertEquals(value_6, a[computed_6()]); // Test non-constant key
     assertEquals(value_7, a[7]);
-    assertEquals(undefined, a[large_array_size-1]);
-    assertEquals(undefined, a[-1]);
     assertEquals(large_array_size, a.length);
     assertTrue(%HasFastDoubleElements(a));
   }
 
   function test_various_loads2(a, value_5, value_6, value_7) {
     assertTrue(%HasFastDoubleElements(a));
     assertEquals(value_5, a[5]);
     assertEquals(value_6, a[6]);
     assertEquals(value_6, a[computed_6()]); // Test non-constant key
     assertEquals(value_7, a[7]);
-    assertEquals(undefined, a[large_array_size-1]);
-    assertEquals(undefined, a[-1]);
     assertEquals(large_array_size, a.length);
     assertTrue(%HasFastDoubleElements(a));
   }
 
   function test_various_loads3(a, value_5, value_6, value_7) {
     assertTrue(%HasFastDoubleElements(a));
     assertEquals(value_5, a[5]);
     assertEquals(value_6, a[6]);
     assertEquals(value_6, a[computed_6()]); // Test non-constant key
     assertEquals(value_7, a[7]);
-    assertEquals(undefined, a[large_array_size-1]);
-    assertEquals(undefined, a[-1]);
     assertEquals(large_array_size, a.length);
     assertTrue(%HasFastDoubleElements(a));
   }
 
   function test_various_loads4(a, value_5, value_6, value_7) {
     assertTrue(%HasFastDoubleElements(a));
     assertEquals(value_5, a[5]);
     assertEquals(value_6, a[6]);
     assertEquals(value_6, a[computed_6()]); // Test non-constant key
     assertEquals(value_7, a[7]);
-    assertEquals(undefined, a[large_array_size-1]);
-    assertEquals(undefined, a[-1]);
     assertEquals(large_array_size, a.length);
     assertTrue(%HasFastDoubleElements(a));
   }
 
   function test_various_loads5(a, value_5, value_6, value_7) {
     assertTrue(%HasFastDoubleElements(a));
-    assertEquals(value_5, a[5]);
-    assertEquals(value_6, a[6]);
-    assertEquals(value_6, a[computed_6()]); // Test non-constant key
+    if (value_5 != undefined) {
+      assertEquals(value_5, a[5]);
+    };
+    if (value_6 != undefined) {
+      assertEquals(value_6, a[6]);
+      assertEquals(value_6, a[computed_6()]); // Test non-constant key
+    }
     assertEquals(value_7, a[7]);
-    assertEquals(undefined, a[large_array_size-1]);
-    assertEquals(undefined, a[-1]);
     assertEquals(large_array_size, a.length);
     assertTrue(%HasFastDoubleElements(a));
   }
 
   function test_various_loads6(a, value_5, value_6, value_7) {
     assertTrue(%HasFastDoubleElements(a));
     assertEquals(value_5, a[5]);
     assertEquals(value_6, a[6]);
     assertEquals(value_6, a[computed_6()]); // Test non-constant key
     assertEquals(value_7, a[7]);
-    assertEquals(undefined, a[large_array_size-1]);
-    assertEquals(undefined, a[-1]);
     assertEquals(large_array_size, a.length);
     assertTrue(%HasFastDoubleElements(a));
   }
+
+  function test_various_loads7(a, value_5, value_6, value_7) {
+    assertTrue(%HasFastDoubleElements(a));
+    assertEquals(value_5, a[5]);
+    assertEquals(value_6, a[6]);
+    assertEquals(value_6, a[computed_6()]); // Test non-constant key
+    assertEquals(value_7, a[7]);
+    assertEquals(large_array_size, a.length);
+    assertTrue(%HasFastDoubleElements(a));
+  }
 
   function test_various_stores(a, value_5, value_6, value_7) {
     assertTrue(%HasFastDoubleElements(a));
     a[5] = value_5;
     a[computed_6()] = value_6;
     a[7] = value_7;
     assertTrue(%HasFastDoubleElements(a));
   }
 
   // Test double and integer values
@@ skipping 86 matching lines @@
   test_various_loads5(large_array,
                       undefined,
                       undefined,
                       expected_array_value(7));
   test_various_loads5(large_array,
                       undefined,
                       undefined,
                       expected_array_value(7));
 
   // Make sure Crankshaft code handles the hole correctly (bailout)
+  var large_array = new allocator(large_array_size);
+  force_to_fast_double_array(large_array);
   test_various_stores(large_array,
                       expected_array_value(5),
                       expected_array_value(6),
                       expected_array_value(7));
   test_various_loads6(large_array,
                       expected_array_value(5),
                       expected_array_value(6),
                       expected_array_value(7));
   test_various_loads6(large_array,
                       expected_array_value(5),
                       expected_array_value(6),
                       expected_array_value(7));
   %OptimizeFunctionOnNextCall(test_various_loads6);
   test_various_loads6(large_array,
                       expected_array_value(5),
                       expected_array_value(6),
                       expected_array_value(7));
 
   delete large_array[5];
   delete large_array[6];
   test_various_loads6(large_array,
                       undefined,
                       undefined,
                       expected_array_value(7));
 
+  %DeoptimizeFunction(test_various_loads6);
+  gc();
+
   // Test stores for non-NaN.
+  var large_array = new allocator(large_array_size);
+  force_to_fast_double_array(large_array);
   %OptimizeFunctionOnNextCall(test_various_stores);
   test_various_stores(large_array,
                       expected_array_value(5),
                       expected_array_value(6),
                       expected_array_value(7));
 
   test_various_stores(large_array,
                       expected_array_value(5),
                       expected_array_value(6),
                       expected_array_value(7));
 
-  test_various_loads6(large_array,
+  test_various_loads7(large_array,
                       expected_array_value(5),
                       expected_array_value(6),
                       expected_array_value(7));
+
+  test_various_loads7(large_array,
+                      expected_array_value(5),
+                      expected_array_value(6),
+                      expected_array_value(7));
+
+  %OptimizeFunctionOnNextCall(test_various_loads7);
+
+  test_various_loads7(large_array,
+                      expected_array_value(5),
+                      expected_array_value(6),
+                      expected_array_value(7));
 
   // Test NaN behavior for stores.
   test_various_stores(large_array,
                       NaN,
                       -NaN,
                       expected_array_value(7));
 
   test_various_stores(large_array,
                       NaN,
                       -NaN,
                       expected_array_value(7));
 
-  test_various_loads6(large_array,
+  test_various_loads7(large_array,
                       NaN,
                       -NaN,
                       expected_array_value(7));
 
   // Test Infinity behavior for stores.
   test_various_stores(large_array,
                       Infinity,
                       -Infinity,
                       expected_array_value(7));
 
   test_various_stores(large_array,
                       Infinity,
                       -Infinity,
                       expected_array_value(7));
 
-  test_various_loads6(large_array,
+  test_various_loads7(large_array,
                       Infinity,
                       -Infinity,
                       expected_array_value(7));
 
   assertTrue(%GetOptimizationStatus(test_various_stores) != 2);
 
   // Make sure that we haven't converted from fast double.
   assertTrue(%HasFastDoubleElements(large_array));
 }
 
@@ skipping 96 matching lines @@
   assertEquals(-Infinity, arg4);
   assertEquals(expected_array_value(5), arg5);
 }
 
 large_array3[1] = NaN;
 large_array3[2] = -NaN;
 large_array3[3] = Infinity;
 large_array3[4] = -Infinity;
 
 function call_apply() {
-  assertTrue(%HasFastDoubleElements(large_array3));
   called_by_apply.apply({}, large_array3);
 }
 
 call_apply();
 call_apply();
 call_apply();
 %OptimizeFunctionOnNextCall(call_apply);
 call_apply();
 call_apply();
 call_apply();
 
 function test_for_in() {
   // Due to previous tests, keys 0..25 and 95 should be present.
   next_expected = 0;
-  assertTrue(%HasFastDoubleElements(large_array3));
   for (x in large_array3) {
     assertTrue(next_expected++ == x);
     if (next_expected == 25) {
       next_expected = 95;
     }
   }
   assertTrue(next_expected == 96);
 }
 
 test_for_in();
@@ skipping 55 matching lines @@
   assertEquals(expected_array_value(2), large_array4[2]);
 }
 
 test_setter();
 test_setter();
 test_setter();
 %OptimizeFunctionOnNextCall(test_setter);
 test_setter();
 test_setter();
 test_setter();