Prevent deopt on double value assignment to typed arrays

test/mjsunit/external-array.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 69 matching lines @@
 assertEquals(2.5, get(array, 0));
 assertEquals(3.5, get(array, 1));
 }
 
 // Test loads and stores.
 types = [Array, Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array,
          Uint32Array, PixelArray, Float32Array, Float64Array];
 
 test_result_nan = [NaN, 0, 0, 0, 0, 0, 0, 0, NaN, NaN];
 test_result_low_int = [-1, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1, -1];
+test_result_low_double = [-1.25, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1.25, -1.25];
 test_result_middle = [253.75, -3, 253, 253, 253, 253, 253, 254, 253.75, 253.75];
 test_result_high_int = [256, 0, 0, 256, 256, 256, 256, 255, 256, 256];
+test_result_high_double = [256.25, 0, 0, 256, 256, 256, 256, 255, 256.25, 256.25];
 
 const kElementCount = 40;
 
 function test_load(array, sum) {
   for (var i = 0; i < kElementCount; i++) {
     sum += array[i];
   }
   return sum;
 }
 
@@ skipping 11 matching lines @@
   return sum;
 }
 
 function test_store_const_key(array, sum) {
   sum += array[0] = 1;
   sum += array[1] = 2;
   sum += array[2] = 3;
   return sum;
 }
 
+function zero() {
+  return 0.0;
+}
 
-function test_store_middle_double(array, sum) {
+function test_store_middle_tagged(array, sum) {
   array[0] = 253.75;
   return array[0];
 }
 
-
-function test_store_high_double(array, sum) {
+function test_store_high_tagged(array, sum) {
   array[0] = 256.25;
   return array[0];
 }
 
+function test_store_middle_double(array, sum) {
+  array[0] = 253.75 + zero(); // + forces double type feedback
+  return array[0];
+}
+
+function test_store_high_double(array, sum) {
+  array[0] = 256.25 + zero(); // + forces double type feedback
+  return array[0];
+}
+
 function test_store_high_double(array, sum) {
   array[0] = 256.25;
   return array[0];
 }
 
 function test_store_low_int(array, sum) {
   array[0] = -1;
   return array[0];
 }
 
+function test_store_low_tagged(array, sum) {
+  array[0] = -1.25;
+  return array[0];
+}
+
+function test_store_low_double(array, sum) {
+  array[0] = -1.25 + zero(); // + forces double type feedback
+  return array[0];
+}
+
 function test_store_high_int(array, sum) {
   array[0] = 256;
   return array[0];
 }
 
 function test_store_nan(array, sum) {
   array[0] = NaN;
   return array[0];
 }
 
 const kRuns = 10;
 
 function run_test(test_func, array, expected_result) {
   for (var i = 0; i < 5; i++) test_func(array, 0);
   %OptimizeFunctionOnNextCall(test_func);
   var sum = 0;
   for (var i = 0; i < kRuns; i++) {
     sum = test_func(array, sum);
   }
   assertEquals(expected_result, sum);
   %DeoptimizeFunction(test_func);
   gc();  // Makes V8 forget about type information for test_func.
 }
 
 for (var t = 0; t < types.length; t++) {
   var type = types[t];
-  print ("type = " + t);
   var a = new type(kElementCount);
   for (var i = 0; i < kElementCount; i++) {
     a[i] = i;
   }
 
   // Run test functions defined above.
   run_test(test_load, a, 780 * kRuns);
   run_test(test_load_const_key, a, 3 * kRuns);
   run_test(test_store, a, 820 * kRuns);
   run_test(test_store_const_key, a, 6 * kRuns);
   run_test(test_store_low_int, a, test_result_low_int[t]);
+  run_test(test_store_low_double, a, test_result_low_double[t]);
+  run_test(test_store_low_tagged, a, test_result_low_double[t]);
   run_test(test_store_high_int, a, test_result_high_int[t]);
   run_test(test_store_nan, a, test_result_nan[t]);
   run_test(test_store_middle_double, a, test_result_middle[t]);
+  run_test(test_store_middle_tagged, a, test_result_middle[t]);
+  run_test(test_store_high_double, a, test_result_high_double[t]);
+  run_test(test_store_high_tagged, a, test_result_high_double[t]);
 
   // Test the correct behavior of the |length| property (which is read-only).
   if (t != 0) {
     assertEquals(kElementCount, a.length);
     a.length = 2;
     assertEquals(kElementCount, a.length);
     assertTrue(delete a.length);
     a.length = 2;
     assertEquals(2, a.length);
   }
 
   function array_load_set_smi_check(a) {
     return a[0] = a[0] = 1;
   }
 
   array_load_set_smi_check(a);
   array_load_set_smi_check(0);
 
   function array_load_set_smi_check2(a) {
     return a[0] = a[0] = 1;
   }
 
   array_load_set_smi_check2(a);
   %OptimizeFunctionOnNextCall(array_load_set_smi_check2);
   array_load_set_smi_check2(a);
   array_load_set_smi_check2(0);
   %DeoptimizeFunction(array_load_set_smi_check2);
   gc();  // Makes V8 forget about type information for array_load_set_smi_check.
 }