In Atomics API, convert operands to numbers before calling runtime.

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-atomics --harmony-sharedarraybuffer
 //
 
 function toRangeWrapped(value) {
   var range = this.max - this.min + 1;
   while (value < this.min) {
@@ skipping 143 matching lines @@
     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);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {

[Jarin, 2015/07/13 05:05:55]

Maybe you should also try an object with a toString method (which should be
called by the toNumber conversion).

[binji, 2015/07/13 19:29:11]

Done.

+      sta[0] = 50;
+      assertEquals(50, Atomics.compareExchange(sta, 0, v, v), 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;
@@ skipping 31 matching lines @@
     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);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {
+      assertEquals(+v, Atomics.store(sta, 0, v), 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);
 
       assertEquals(50, Atomics.add(sta, i, 70), name);
       assertEquals(120, sta[i], name);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {
+      sta[0] = 120;
+      assertEquals(120, Atomics.add(sta, 0, v), name);
+      assertEquals(120 + (v|0), sta[0], name);
+    });
   });
 })();
 
 (function TestSub() {
   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] = 120;
       assertEquals(120, Atomics.sub(sta, i, 50), name);
       assertEquals(70, sta[i], name);
 
       assertEquals(70, Atomics.sub(sta, i, 70), name);
       assertEquals(0, sta[i], name);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {
+      sta[0] = 70;
+      assertEquals(70, Atomics.sub(sta, 0, v), name);
+      assertEquals(70 - (v|0), sta[0]);
+    });
   });
 })();
 
 (function TestAnd() {
   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] = 0x3f;
       assertEquals(0x3f, Atomics.and(sta, i, 0x30), name);
       assertEquals(0x30, sta[i], name);
 
       assertEquals(0x30, Atomics.and(sta, i, 0x20), name);
       assertEquals(0x20, sta[i], name);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {
+      sta[0] = 0x20;
+      assertEquals(0x20, Atomics.and(sta, 0, v), name);
+      assertEquals(0x20 & (v|0), sta[0]);
+    });
   });
 })();
 
 (function TestOr() {
   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] = 0x30;
       assertEquals(0x30, Atomics.or(sta, i, 0x1c), name);
       assertEquals(0x3c, sta[i], name);
 
       assertEquals(0x3c, Atomics.or(sta, i, 0x09), name);
       assertEquals(0x3d, sta[i], name);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {
+      sta[0] = 0x3d;
+      assertEquals(0x3d, Atomics.or(sta, 0, v), name);
+      assertEquals(0x3d | (v|0), sta[0]);
+    });
   });
 })();
 
 (function TestXor() {
   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] = 0x30;
       assertEquals(0x30, Atomics.xor(sta, i, 0x1c), name);
       assertEquals(0x2c, sta[i], name);
 
       assertEquals(0x2c, Atomics.xor(sta, i, 0x09), name);
       assertEquals(0x25, sta[i], name);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {
+      sta[0] = 0x25;
+      assertEquals(0x25, Atomics.xor(sta, 0, v), name);
+      assertEquals(0x25 ^ (v|0), sta[0]);
+    });
   });
 })();
 
 (function TestExchange() {
   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] = 0x30;
       assertEquals(0x30, Atomics.exchange(sta, i, 0x1c), name);
       assertEquals(0x1c, sta[i], name);
 
       assertEquals(0x1c, Atomics.exchange(sta, i, 0x09), name);
       assertEquals(0x09, sta[i], name);
     }
+
+    // Non-numbers should be coerced to numbers.
+    [false, true, undefined].forEach(function(v) {
+      sta[0] = 0x09;
+      assertEquals(0x09, Atomics.exchange(sta, 0, v), name);
+      assertEquals(v|0, sta[0]);
+    });
   });
 })();
 
 (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
@@ skipping 101 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);
     }
 
   });
 })();