[Atomics] code stubs for atomic operations

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) {
     value += range;
   }
   while (value > this.max) {
     value -= range;
   }
   return value;
 }
 
-function toRangeClamped(value) {
-  if (value < this.min) return this.min;
-  if (value > this.max) return this.max;
-  return value;
-}
-
 function makeConstructorObject(constr, min, max, toRange) {
   var o = {constr: constr, min: min, max: max};
-  o.toRange = toRange.bind(o);
+  o.toRange = toRangeWrapped.bind(o);
   return o;
 }
 
 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),
+  makeConstructorObject(Int8Array, -128, 127),
+  makeConstructorObject(Int16Array, -32768, 32767),
+  makeConstructorObject(Int32Array, -0x80000000, 0x7fffffff),
+  makeConstructorObject(Uint8Array, 0, 255),
+  makeConstructorObject(Uint16Array, 0, 65535),
+  makeConstructorObject(Uint32Array, 0, 0xffffffff),
 ];
 
 (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);
+  var u8ca = new Uint8ClampedArray(sab);
 
   // Atomic ops required integer shared typed arrays
-  [undefined, 1, 'hi', 3.4, ab, u32a, sab, sf32a, sf64a].forEach(function(o) {
+  var badArrayTypes = [
+    undefined, 1, 'hi', 3.4, ab, u32a, sab, sf32a, sf64a, u8ca
+  ];
+  badArrayTypes.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);
@@ skipping 62 matching lines @@
   });
 })();
 
 (function TestGoodIndex() {
   var sab = new SharedArrayBuffer(64);
   var si32a = new Int32Array(sab);
   var si32a2 = new Int32Array(sab, 32);
 
   var testOp = function(op, ia, index, expectedIndex, name) {
     for (var i = 0; i < ia.length; ++i)
-      ia[i] = 22;
+      ia[i] = i * 2;
 
     ia[expectedIndex] = 0;
-    assertEquals(0, op(ia, index, 0, 0), name);
+    var result = op(ia, index, 0, 0);
+    assertEquals(0, result, name);
     assertEquals(0, ia[expectedIndex], name);
 
     for (var i = 0; i < ia.length; ++i) {
       if (i == expectedIndex) continue;
-      assertEquals(22, ia[i], name);
+      assertEquals(i * 2, ia[i], name);
     }
   };
 
   // These values all map to index 0
   [-0, 0, 0.0, null, false].forEach(function(i) {
     var name = String(i);
     [si32a, si32a2].forEach(function(array) {
       testOp(Atomics.compareExchange, array, i, 0, name);
       testOp(Atomics.load, array, i, 0, name);
       testOp(Atomics.store, array, i, 0, name);
@@ skipping 64 matching lines @@
       clearArray(array.buffer);
       var name = Object.prototype.toString.call(array);
       for (var i = 0; i < array.length; ++i) {
         array[i] = 0;
         assertEquals(0, Atomics.load(array, i), name);
         array[i] = 50;
         assertEquals(50, Atomics.load(array, i), name);
       }
     })
   });
+
+  // Test Smi range
+  (function () {
+    var sab = new SharedArrayBuffer(4);
+    var i32 = new Int32Array(sab);
+    var u32 = new Uint32Array(sab);
+
+    function testLoad(signedValue, unsignedValue) {
+      u32[0] = unsignedValue;
+      assertEquals(unsignedValue, Atomics.load(u32, 0));
+      assertEquals(signedValue, Atomics.load(i32, 0));
+    }
+
+    testLoad(0x3fffffff,  0x3fffffff); // 2**30-1 (always smi)
+    testLoad(0x40000000,  0x40000000); // 2**30 (smi if signed and 32-bits)
+    testLoad(0x80000000, -0x80000000); // 2**31 (smi if signed and 32-bits)
+    testLoad(0xffffffff, -1);          // 2**31 (smi if signed)
+  });
 })();
 
 (function TestStore() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
     var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
     [sta, sta2].forEach(function(array) {
       clearArray(array.buffer);
@@ skipping 297 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);
     }
 
   });
 })();