V8 JavaScript shared memory prototype.

src/arraybuffer.js

 // Copyright 2013 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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 "use strict";
 
 var $ArrayBuffer = global.ArrayBuffer;
 
 // -------------------------------------------------------------------
 
-function ArrayBufferConstructor(length) { // length = 1
+function ArrayBufferConstructor(length, shared) { // length = 1
   if (%_IsConstructCall()) {
     var byteLength = ToPositiveInteger(length, 'invalid_array_buffer_length');
-    %ArrayBufferInitialize(this, byteLength);
+    var is_shared = !!shared;
+      %ArrayBufferInitialize(this, byteLength, is_shared);
   } else {
     throw MakeTypeError('constructor_not_function', ["ArrayBuffer"]);
   }
 }
 
 function ArrayBufferGetByteLength() {
   if (!IS_ARRAYBUFFER(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['ArrayBuffer.prototype.byteLength', this]);
   }
   return %_ArrayBufferGetByteLength(this);
 }
 
+function ArrayBufferGetShared() {
+  if (!IS_ARRAYBUFFER(this)) {
+    throw MakeTypeError('incompatible_method_receiver',
+                        ['ArrayBuffer.prototype.shared', this]);
+  }
+  return %ArrayBufferGetShared(this);
+}
+
 // ES6 Draft 15.13.5.5.3
 function ArrayBufferSlice(start, end) {
   if (!IS_ARRAYBUFFER(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['ArrayBuffer.prototype.slice', this]);
   }
 
   var relativeStart = TO_INTEGER(start);
   if (!IS_UNDEFINED(end)) {
     end = TO_INTEGER(end);
@@ skipping 21 matching lines @@
   var result = new $ArrayBuffer(newLen);
 
   %ArrayBufferSliceImpl(this, result, first);
   return result;
 }
 
 function ArrayBufferIsView(obj) {
   return %ArrayBufferIsView(obj);
 }
 
+function ArrayBufferMutexInit(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferMutexInit(this, a);
+}
+
+function ArrayBufferMutexDestroy(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferMutexDestroy(this, a);
+}
+
+function ArrayBufferMutexLock(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferMutexLock(this, a);
+}
+
+function ArrayBufferMutexUnlock(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferMutexUnlock(this, a);
+}
+
+function ArrayBufferMutexSize(obj) {
+  return %ArrayBufferMutexSize(obj);
+}
+
+function ArrayBufferCondInit(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferCondInit(this, a);
+}
+
+function ArrayBufferCondDestroy(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferCondDestroy(this, a);
+}
+
+function ArrayBufferCondWait(caddr, maddr) {
+  var ca = TO_INTEGER(caddr);
+  var ma = TO_INTEGER(maddr);
+  return %ArrayBufferCondWait(this, ca, ma);
+}
+
+function ArrayBufferCondSignal(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferCondSignal(this, a);
+}
+
+function ArrayBufferCondBroadcast(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferCondBroadcast(this, a);
+}
+
+function ArrayBufferCondSize(obj) {
+  return %ArrayBufferCondSize(obj);
+}
+
+function ArrayBufferBarrierInit(addr, count) {
+  var a = TO_INTEGER(addr);
+  var c = TO_INTEGER(count);
+  return %ArrayBufferBarrierInit(this, a, c);
+}
+
+function ArrayBufferBarrierDestroy(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferBarrierDestroy(this, a);
+}
+
+function ArrayBufferBarrierWait(addr) {
+  var a = TO_INTEGER(addr);
+  return %ArrayBufferBarrierWait(this, a);
+}
+
+function ArrayBufferBarrierSize(obj) {
+  return %ArrayBufferBarrierSize(obj);
+}
+
 function SetUpArrayBuffer() {
   %CheckIsBootstrapping();
 
   // Set up the ArrayBuffer constructor function.
   %SetCode($ArrayBuffer, ArrayBufferConstructor);
   %FunctionSetPrototype($ArrayBuffer, new $Object());
 
   // Set up the constructor property on the ArrayBuffer prototype object.
   %SetProperty($ArrayBuffer.prototype, "constructor", $ArrayBuffer, DONT_ENUM);
 
   InstallGetter($ArrayBuffer.prototype, "byteLength", ArrayBufferGetByteLength);
 
+  InstallGetter($ArrayBuffer.prototype, "shared", ArrayBufferGetShared);
+
   InstallFunctions($ArrayBuffer, DONT_ENUM, $Array(
       "isView", ArrayBufferIsView
   ));
 
   InstallFunctions($ArrayBuffer.prototype, DONT_ENUM, $Array(
+      "mutexInit", ArrayBufferMutexInit,
+      "mutexDestroy", ArrayBufferMutexDestroy,
+      "mutexLock", ArrayBufferMutexLock,
+      "mutexUnlock", ArrayBufferMutexUnlock,
+      "mutexSize", ArrayBufferMutexSize,
+      "condInit", ArrayBufferCondInit,
+      "condDestroy", ArrayBufferCondDestroy,
+      "condWait", ArrayBufferCondWait,
+      "condSignal", ArrayBufferCondSignal,
+      "condBroadcast", ArrayBufferCondBroadcast,
+      "condSize", ArrayBufferCondSize,
+      "barrierInit", ArrayBufferBarrierInit,
+      "barrierDestroy", ArrayBufferBarrierDestroy,
+      "barrierWait", ArrayBufferBarrierWait,
+      "barrierSize", ArrayBufferBarrierSize,
       "slice", ArrayBufferSlice
   ));
 }
 
 SetUpArrayBuffer();