WIP SharedArrayBuffer implementation

src/harmony-sharedtypedarray.js

-// Copyright 2013 the V8 project authors. All rights reserved.
+// Copyright 2015 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.
 
 (function(global, shared, exports) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 var GlobalArray = global.Array;
-var GlobalArrayBuffer = global.ArrayBuffer;
+var GlobalSharedArrayBuffer = global.SharedArrayBuffer;
 var GlobalDataView = global.DataView;
 var GlobalObject = global.Object;
 
-macro TYPED_ARRAYS(FUNCTION)
+macro SHARED_TYPED_ARRAYS(FUNCTION)
 // arrayIds below should be synchronized with Runtime_TypedArrayInitialize.
-FUNCTION(1, Uint8Array, 1)
-FUNCTION(2, Int8Array, 1)
-FUNCTION(3, Uint16Array, 2)
-FUNCTION(4, Int16Array, 2)
-FUNCTION(5, Uint32Array, 4)
-FUNCTION(6, Int32Array, 4)
-FUNCTION(7, Float32Array, 4)
-FUNCTION(8, Float64Array, 8)
-FUNCTION(9, Uint8ClampedArray, 1)
+FUNCTION(1, SharedUint8Array, 1)
+FUNCTION(2, SharedInt8Array, 1)
+FUNCTION(3, SharedUint16Array, 2)
+FUNCTION(4, SharedInt16Array, 2)
+FUNCTION(5, SharedUint32Array, 4)
+FUNCTION(6, SharedInt32Array, 4)
+FUNCTION(7, SharedFloat32Array, 4)
+FUNCTION(8, SharedFloat64Array, 8)
+FUNCTION(9, SharedUint8ClampedArray, 1)
 endmacro
 
 macro DECLARE_GLOBALS(INDEX, NAME, SIZE)
 var GlobalNAME = global.NAME;
 endmacro
 
-TYPED_ARRAYS(DECLARE_GLOBALS)
+SHARED_TYPED_ARRAYS(DECLARE_GLOBALS)
 
-// --------------- Typed Arrays ---------------------
+// --------------- Shared Typed Arrays ---------------------
 
-macro TYPED_ARRAY_CONSTRUCTOR(ARRAY_ID, NAME, ELEMENT_SIZE)
+macro SHARED_TYPED_ARRAY_CONSTRUCTOR(ARRAY_ID, NAME, ELEMENT_SIZE)
 function NAMEConstructByArrayBuffer(obj, buffer, byteOffset, length) {
   if (!IS_UNDEFINED(byteOffset)) {
       byteOffset =
-          $toPositiveInteger(byteOffset, kInvalidTypedArrayLength);
+          $toPositiveInteger(byteOffset,  kInvalidTypedArrayLength);
   }
   if (!IS_UNDEFINED(length)) {
       length = $toPositiveInteger(length, kInvalidTypedArrayLength);
   }
 
   var bufferByteLength = %_ArrayBufferGetByteLength(buffer);
   var offset;
   if (IS_UNDEFINED(byteOffset)) {
     offset = 0;
   } else {
     offset = byteOffset;
 
     if (offset % ELEMENT_SIZE !== 0) {
-      throw MakeRangeError(kInvalidTypedArrayAlignment,
-                           "start offset", "NAME", ELEMENT_SIZE);
+      throw MakeRangeError(kInvalidTypedArrayAlignment, "start offset", "NAME",
+                           ELEMENT_SIZE);
     }
     if (offset > bufferByteLength) {
       throw MakeRangeError(kInvalidTypedArrayOffset);
     }
   }
 
   var newByteLength;
   var newLength;
   if (IS_UNDEFINED(length)) {
     if (bufferByteLength % ELEMENT_SIZE !== 0) {
-      throw MakeRangeError(kInvalidTypedArrayAlignment,
-                           "byte length", "NAME", ELEMENT_SIZE);
+      throw MakeRangeError(kInvalidTypedArrayAlignment, "byte length", "NAME",
+                           ELEMENT_SIZE);
     }
     newByteLength = bufferByteLength - offset;
     newLength = newByteLength / ELEMENT_SIZE;
   } else {
     var newLength = length;
     newByteLength = newLength * ELEMENT_SIZE;
   }
   if ((offset + newByteLength > bufferByteLength)
       || (newLength > %_MaxSmi())) {
     throw MakeRangeError(kInvalidTypedArrayLength);
   }
   %_TypedArrayInitialize(obj, ARRAY_ID, buffer, offset, newByteLength);
 }
 
 function NAMEConstructByLength(obj, length) {
   var l = IS_UNDEFINED(length) ?
     0 : $toPositiveInteger(length, kInvalidTypedArrayLength);
   if (l > %_MaxSmi()) {
     throw MakeRangeError(kInvalidTypedArrayLength);
   }
   var byteLength = l * ELEMENT_SIZE;
-  if (byteLength > %_TypedArrayMaxSizeInHeap()) {
-    var buffer = new GlobalArrayBuffer(byteLength);
-    %_TypedArrayInitialize(obj, ARRAY_ID, buffer, 0, byteLength);
-  } else {
-    %_TypedArrayInitialize(obj, ARRAY_ID, null, 0, byteLength);
-  }
-}
-
-function NAMEConstructByArrayLike(obj, arrayLike) {
-  var length = arrayLike.length;
-  var l = $toPositiveInteger(length, kInvalidTypedArrayLength);
-
-  if (l > %_MaxSmi()) {
-    throw MakeRangeError(kInvalidTypedArrayLength);
-  }
-  if(!%TypedArrayInitializeFromArrayLike(obj, ARRAY_ID, arrayLike, l)) {
-    for (var i = 0; i < l; i++) {
-      // It is crucial that we let any execptions from arrayLike[i]
-      // propagate outside the function.
-      obj[i] = arrayLike[i];
-    }
-  }
+  var buffer = new GlobalSharedArrayBuffer(byteLength);
+  %_TypedArrayInitialize(obj, ARRAY_ID, buffer, 0, byteLength);
 }
 
 function NAMEConstructor(arg1, arg2, arg3) {
   if (%_IsConstructCall()) {
-    if (IS_ARRAYBUFFER(arg1)) {
+    if (IS_SHAREDARRAYBUFFER(arg1)) {
       NAMEConstructByArrayBuffer(this, arg1, arg2, arg3);
     } else if (IS_NUMBER(arg1) || IS_STRING(arg1) ||
                IS_BOOLEAN(arg1) || IS_UNDEFINED(arg1)) {
       NAMEConstructByLength(this, arg1);
     } else {
-      NAMEConstructByArrayLike(this, arg1);
+      throw MakeTypeError(kInvalidArgument);
     }
   } else {
     throw MakeTypeError(kConstructorNotFunction, "NAME")
   }
 }
 
 function NAME_GetBuffer() {
   if (!(%_ClassOf(this) === 'NAME')) {
     throw MakeTypeError(kIncompatibleMethodReceiver, "NAME.buffer", this);
   }
@@ skipping 42 matching lines @@
     endInt = $max(0, srcLength + endInt);
   } else {
     endInt = $min(endInt, srcLength);
   }
   if (endInt < beginInt) {
     endInt = beginInt;
   }
   var newLength = endInt - beginInt;
   var beginByteOffset =
       %_ArrayBufferViewGetByteOffset(this) + beginInt * ELEMENT_SIZE;
-  return new GlobalNAME(%TypedArrayGetBuffer(this),
-                        beginByteOffset, newLength);
+  return new GlobalNAME(%TypedArrayGetBuffer(this), beginByteOffset,
+                        newLength);
 }
 endmacro
 
-TYPED_ARRAYS(TYPED_ARRAY_CONSTRUCTOR)
-
+SHARED_TYPED_ARRAYS(SHARED_TYPED_ARRAY_CONSTRUCTOR)
 
 function TypedArraySetFromArrayLike(target, source, sourceLength, offset) {
   if (offset > 0) {
     for (var i = 0; i < sourceLength; i++) {
       target[offset + i] = source[i];
     }
   }
   else {
     for (var i = 0; i < sourceLength; i++) {
       target[i] = source[i];
@@ skipping 92 matching lines @@
 
 function TypedArrayGetToStringTag() {
   if (!%IsTypedArray(this)) return;
   var name = %_ClassOf(this);
   if (IS_UNDEFINED(name)) return;
   return name;
 }
 
 // -------------------------------------------------------------------
 
-macro SETUP_TYPED_ARRAY(ARRAY_ID, NAME, ELEMENT_SIZE)
+
+macro SETUP_SHARED_TYPED_ARRAY(ARRAY_ID, NAME, ELEMENT_SIZE)
   %SetCode(GlobalNAME, NAMEConstructor);
   %FunctionSetPrototype(GlobalNAME, new GlobalObject());
 
   %AddNamedProperty(GlobalNAME, "BYTES_PER_ELEMENT", ELEMENT_SIZE,
                     READ_ONLY | DONT_ENUM | DONT_DELETE);
   %AddNamedProperty(GlobalNAME.prototype,
                     "constructor", global.NAME, DONT_ENUM);
   %AddNamedProperty(GlobalNAME.prototype,
                     "BYTES_PER_ELEMENT", ELEMENT_SIZE,
                     READ_ONLY | DONT_ENUM | DONT_DELETE);
   $installGetter(GlobalNAME.prototype, "buffer", NAME_GetBuffer);
   $installGetter(GlobalNAME.prototype, "byteOffset", NAME_GetByteOffset,
                  DONT_ENUM | DONT_DELETE);
   $installGetter(GlobalNAME.prototype, "byteLength", NAME_GetByteLength,
                  DONT_ENUM | DONT_DELETE);
   $installGetter(GlobalNAME.prototype, "length", NAME_GetLength,
                  DONT_ENUM | DONT_DELETE);
   $installGetter(GlobalNAME.prototype, symbolToStringTag,
                  TypedArrayGetToStringTag);
   $installFunctions(GlobalNAME.prototype, DONT_ENUM, [
     "subarray", NAMESubArray,
     "set", TypedArraySet
   ]);
 endmacro
 
-TYPED_ARRAYS(SETUP_TYPED_ARRAY)
-
-// --------------------------- DataView -----------------------------
-
-function DataViewConstructor(buffer, byteOffset, byteLength) { // length = 3
-  if (%_IsConstructCall()) {
-    if (!IS_ARRAYBUFFER(buffer)) throw MakeTypeError(kDataViewNotArrayBuffer);
-    if (!IS_UNDEFINED(byteOffset)) {
-        byteOffset = $toPositiveInteger(byteOffset, kInvalidDataViewOffset);
-    }
-    if (!IS_UNDEFINED(byteLength)) {
-        byteLength = TO_INTEGER(byteLength);
-    }
-
-    var bufferByteLength = %_ArrayBufferGetByteLength(buffer);
-
-    var offset = IS_UNDEFINED(byteOffset) ?  0 : byteOffset;
-    if (offset > bufferByteLength) throw MakeRangeError(kInvalidDataViewOffset);
-
-    var length = IS_UNDEFINED(byteLength)
-        ? bufferByteLength - offset
-        : byteLength;
-    if (length < 0 || offset + length > bufferByteLength) {
-      throw new MakeRangeError(kInvalidDataViewLength);
-    }
-    %_DataViewInitialize(this, buffer, offset, length);
-  } else {
-    throw MakeTypeError(kConstructorNotFunction, "DataView");
-  }
-}
-
-function DataViewGetBufferJS() {
-  if (!IS_DATAVIEW(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver, 'DataView.buffer', this);
-  }
-  return %DataViewGetBuffer(this);
-}
-
-function DataViewGetByteOffset() {
-  if (!IS_DATAVIEW(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
-                        'DataView.byteOffset', this);
-  }
-  return %_ArrayBufferViewGetByteOffset(this);
-}
-
-function DataViewGetByteLength() {
-  if (!IS_DATAVIEW(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
-                        'DataView.byteLength', this);
-  }
-  return %_ArrayBufferViewGetByteLength(this);
-}
-
-macro DATA_VIEW_TYPES(FUNCTION)
-  FUNCTION(Int8)
-  FUNCTION(Uint8)
-  FUNCTION(Int16)
-  FUNCTION(Uint16)
-  FUNCTION(Int32)
-  FUNCTION(Uint32)
-  FUNCTION(Float32)
-  FUNCTION(Float64)
-endmacro
-
-
-macro DATA_VIEW_GETTER_SETTER(TYPENAME)
-function DataViewGetTYPENAMEJS(offset, little_endian) {
-  if (!IS_DATAVIEW(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
-                        'DataView.getTYPENAME', this);
-  }
-  if (%_ArgumentsLength() < 1) throw MakeTypeError(kInvalidArgument);
-  offset = $toPositiveInteger(offset, kInvalidDataViewAccessorOffset);
-  return %DataViewGetTYPENAME(this, offset, !!little_endian);
-}
-
-function DataViewSetTYPENAMEJS(offset, value, little_endian) {
-  if (!IS_DATAVIEW(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
-                        'DataView.setTYPENAME', this);
-  }
-  if (%_ArgumentsLength() < 2) throw MakeTypeError(kInvalidArgument);
-  offset = $toPositiveInteger(offset, kInvalidDataViewAccessorOffset);
-  %DataViewSetTYPENAME(this, offset, TO_NUMBER_INLINE(value), !!little_endian);
-}
-endmacro
-
-DATA_VIEW_TYPES(DATA_VIEW_GETTER_SETTER)
-
-// Setup the DataView constructor.
-%SetCode(GlobalDataView, DataViewConstructor);
-%FunctionSetPrototype(GlobalDataView, new GlobalObject);
-
-// Set up constructor property on the DataView prototype.
-%AddNamedProperty(GlobalDataView.prototype, "constructor", GlobalDataView,
-                  DONT_ENUM);
-%AddNamedProperty(GlobalDataView.prototype, symbolToStringTag, "DataView",
-                  READ_ONLY|DONT_ENUM);
-
-$installGetter(GlobalDataView.prototype, "buffer", DataViewGetBufferJS);
-$installGetter(GlobalDataView.prototype, "byteOffset", DataViewGetByteOffset);
-$installGetter(GlobalDataView.prototype, "byteLength", DataViewGetByteLength);
-
-$installFunctions(GlobalDataView.prototype, DONT_ENUM, [
-  "getInt8", DataViewGetInt8JS,
-  "setInt8", DataViewSetInt8JS,
-
-  "getUint8", DataViewGetUint8JS,
-  "setUint8", DataViewSetUint8JS,
-
-  "getInt16", DataViewGetInt16JS,
-  "setInt16", DataViewSetInt16JS,
-
-  "getUint16", DataViewGetUint16JS,
-  "setUint16", DataViewSetUint16JS,
-
-  "getInt32", DataViewGetInt32JS,
-  "setInt32", DataViewSetInt32JS,
-
-  "getUint32", DataViewGetUint32JS,
-  "setUint32", DataViewSetUint32JS,
-
-  "getFloat32", DataViewGetFloat32JS,
-  "setFloat32", DataViewSetFloat32JS,
-
-  "getFloat64", DataViewGetFloat64JS,
-  "setFloat64", DataViewSetFloat64JS
-]);
+SHARED_TYPED_ARRAYS(SETUP_SHARED_TYPED_ARRAY)
 
 })