[Atomics] Remove support for atomic accesses on floating-point values.

test/mjsunit/harmony/atomics.js

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --harmony-sharedarraybuffer
 //
 
 function toRangeWrapped(value) {
   var range = this.max - this.min + 1;
   while (value < this.min) {
@@ skipping 20 matching lines @@
 var IntegerTypedArrayConstructors = [
   makeConstructorObject(Int8Array, -128, 127, toRangeWrapped),
   makeConstructorObject(Int16Array, -32768, 32767, toRangeWrapped),
   makeConstructorObject(Int32Array, -0x80000000, 0x7fffffff, toRangeWrapped),
   makeConstructorObject(Uint8Array, 0, 255, toRangeWrapped),
   makeConstructorObject(Uint8ClampedArray, 0, 255, toRangeClamped),
   makeConstructorObject(Uint16Array, 0, 65535, toRangeWrapped),
   makeConstructorObject(Uint32Array, 0, 0xffffffff, toRangeWrapped),
 ];
 
-var TypedArrayConstructors = IntegerTypedArrayConstructors.concat([
-  {constr: Float32Array},
-  {constr: Float64Array},
-]);
-
 (function TestBadArray() {
   var ab = new ArrayBuffer(16);
   var u32a = new Uint32Array(16);
   var sab = new SharedArrayBuffer(128);
   var sf32a = new Float32Array(sab);
   var sf64a = new Float64Array(sab);
 
-  // Atomic ops required shared typed arrays
-  [undefined, 1, 'hi', 3.4, ab, u32a, sab].forEach(function(o) {
+  // Atomic ops required integer shared typed arrays
+  [undefined, 1, 'hi', 3.4, ab, u32a, sab, sf32a, sf64a].forEach(function(o) {
     assertThrows(function() { Atomics.compareExchange(o, 0, 0, 0); },
                  TypeError);
     assertThrows(function() { Atomics.load(o, 0); }, TypeError);
     assertThrows(function() { Atomics.store(o, 0, 0); }, TypeError);
     assertThrows(function() { Atomics.add(o, 0, 0); }, TypeError);
     assertThrows(function() { Atomics.sub(o, 0, 0); }, TypeError);
     assertThrows(function() { Atomics.and(o, 0, 0); }, TypeError);
     assertThrows(function() { Atomics.or(o, 0, 0); }, TypeError);
     assertThrows(function() { Atomics.xor(o, 0, 0); }, TypeError);
     assertThrows(function() { Atomics.exchange(o, 0, 0); }, TypeError);
   });
-
-  // Arithmetic atomic ops require integer shared arrays
-  [sab, sf32a, sf64a].forEach(function(o) {
-    assertThrows(function() { Atomics.add(o, 0, 0); }, TypeError);
-    assertThrows(function() { Atomics.sub(o, 0, 0); }, TypeError);
-    assertThrows(function() { Atomics.and(o, 0, 0); }, TypeError);
-    assertThrows(function() { Atomics.or(o, 0, 0); }, TypeError);
-    assertThrows(function() { Atomics.xor(o, 0, 0); }, TypeError);
-    assertThrows(function() { Atomics.exchange(o, 0, 0); }, TypeError);
-  });
 })();
 
 function testAtomicOp(op, ia, index, expectedIndex, name) {
   for (var i = 0; i < ia.length; ++i)
     ia[i] = 22;
 
   ia[expectedIndex] = 0;
   assertEquals(0, op(ia, index, 0, 0), name);
   assertEquals(0, ia[expectedIndex], name);
 
@@ skipping 70 matching lines @@
     testAtomicOp(Atomics.add, si32a, i, 3, name);
     testAtomicOp(Atomics.sub, si32a, i, 3, name);
     testAtomicOp(Atomics.and, si32a, i, 3, name);
     testAtomicOp(Atomics.or, si32a, i, 3, name);
     testAtomicOp(Atomics.xor, si32a, i, 3, name);
     testAtomicOp(Atomics.exchange, si32a, i, 3, name);
   });
 })();
 
 (function TestCompareExchange() {
-  TypedArrayConstructors.forEach(function(t) {
+  IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
     var name = Object.prototype.toString.call(sta);
     for (var i = 0; i < 10; ++i) {
       // sta[i] == 0, CAS will store
       assertEquals(0, Atomics.compareExchange(sta, i, 0, 50), name);
       assertEquals(50, sta[i], name);
 
       // sta[i] == 50, CAS will not store
       assertEquals(50, Atomics.compareExchange(sta, i, 0, 100), name);
       assertEquals(50, sta[i], name);
     }
   });
-
-  // * Exact float values should be OK
-  // * Infinity, -Infinity should be OK (has exact representation)
-  // * NaN is not OK, it has many representations, cannot ensure successful CAS
-  // because it does a bitwise compare
-  [1.5, 4.25, -1e8, -Infinity, Infinity].forEach(function(v) {
-    var sab = new SharedArrayBuffer(10 * Float32Array.BYTES_PER_ELEMENT);
-    var sf32a = new Float32Array(sab);
-    sf32a[0] = 0;
-    assertEquals(0, Atomics.compareExchange(sf32a, 0, 0, v));
-    assertEquals(v, sf32a[0]);
-    assertEquals(v, Atomics.compareExchange(sf32a, 0, v, 0));
-    assertEquals(0, sf32a[0]);
-
-    var sab2 = new SharedArrayBuffer(10 * Float64Array.BYTES_PER_ELEMENT);
-    var sf64a = new Float64Array(sab2);
-    sf64a[0] = 0;
-    assertEquals(0, Atomics.compareExchange(sf64a, 0, 0, v));
-    assertEquals(v, sf64a[0]);
-    assertEquals(v, Atomics.compareExchange(sf64a, 0, v, 0));
-    assertEquals(0, sf64a[0]);
-  });
 })();
 
 (function TestLoad() {
-  TypedArrayConstructors.forEach(function(t) {
+  IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
     var name = Object.prototype.toString.call(sta);
     for (var i = 0; i < 10; ++i) {
       sta[i] = 0;
       assertEquals(0, Atomics.load(sta, i), name);
       sta[i] = 50;
       assertEquals(50, Atomics.load(sta, i), name);
     }
   });
 })();
 
 (function TestStore() {
-  TypedArrayConstructors.forEach(function(t) {
+  IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
     var name = Object.prototype.toString.call(sta);
     for (var i = 0; i < 10; ++i) {
       assertEquals(50, Atomics.store(sta, i, 50), name);
       assertEquals(50, sta[i], name);
 
       assertEquals(100, Atomics.store(sta, i, 100), name);
       assertEquals(100, sta[i], name);
     }
   });
-
-  [1.5, 4.25, -1e8, -Infinity, Infinity, NaN].forEach(function(v) {
-    var sab = new SharedArrayBuffer(10 * Float32Array.BYTES_PER_ELEMENT);
-    var sf32a = new Float32Array(sab);
-    sf32a[0] = 0;
-    assertEquals(v, Atomics.store(sf32a, 0, v));
-    assertEquals(v, sf32a[0]);
-
-    var sab2 = new SharedArrayBuffer(10 * Float64Array.BYTES_PER_ELEMENT);
-    var sf64a = new Float64Array(sab2);
-    sf64a[0] = 0;
-    assertEquals(v, Atomics.store(sf64a, 0, v));
-    assertEquals(v, sf64a[0]);
-  });
 })();
 
 (function TestAdd() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
     var name = Object.prototype.toString.call(sta);
     for (var i = 0; i < 10; ++i) {
       assertEquals(0, Atomics.add(sta, i, 50), name);
       assertEquals(50, sta[i], name);
@@ skipping 86 matching lines @@
 
 (function TestIsLockFree() {
   // For all platforms we support, 1, 2 and 4 bytes should be lock-free.
   assertEquals(true, Atomics.isLockFree(1));
   assertEquals(true, Atomics.isLockFree(2));
   assertEquals(true, Atomics.isLockFree(4));
 
   // Sizes that aren't equal to a typedarray BYTES_PER_ELEMENT always return
   // false.
   var validSizes = {};
-  TypedArrayConstructors.forEach(function(t) {
+  IntegerTypedArrayConstructors.forEach(function(t) {
     validSizes[t.constr.BYTES_PER_ELEMENT] = true;
   });
 
   for (var i = 0; i < 1000; ++i) {
     if (!validSizes[i]) {
       assertEquals(false, Atomics.isLockFree(i));
     }
   }
 })();
 
@@ skipping 140 matching lines @@
       // Exchange
       sta[0] = val = 0x12;
       operand = 0x22 + offset;
       valWrapped = t.toRange(operand);
       assertEquals(val, Atomics.exchange(sta, 0, operand), name);
       assertEquals(valWrapped, sta[0], name);
     }
 
   });
 })();