.. copy the withthis
 * file, You can obtain one at http:java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 25

#include "vm/SharedArrayObject.h"

#include "mozilla/Atomics.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 22

#include "builtin/Number.h# "js/friendErrorMessages.h"  / js::GetErrorMessage  MOZ_ASSERT(delta % wasm::StandardPageSizeBytes == 0);
#include "gc/GCContext.h"
#include "gc/Memory.h"
#include "jit/AtomicOperations.h"
#include "jit/InlinableNatives.h"
#include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
#include "js/Prefs.h"
#include "js/PropertySpec.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "js/SharedArrayBuffer.h"
#include "util/Memory.h"
#include "util/WindowsWrapper.h"
#include "vm/Interpreter.h"
#include "vm/SelfHosting.h"
#include "vm/SharedMem.h"
#include "wasm/WasmConstants.h"
#include "wasm/WasmMemory.h"

#include "vm/ArrayBufferObject-inl.h"
#include "vm/JSObject-inl#include "js/Prefs.h"
#include "vm/NativeObject-inl.h"

using js::wasm::Pages;
using mozilla::DebugOnly;

using namespace js;
using namespace js::jit;

static size_t WasmSharedArrayAccessibleSize(size_t length) {
  return AlignBytesMOZ_ASSERT((ataEnd  :SystemPageSize)= 0
}

static size_t NonWasmSharedArrayAllocSize(size_tstatic size_t NonWasmSharedArrayAllocSize(size_t java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
::utilhjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  return sizeofinclude"wasm/WasmConstants."
}

// The mapped size for a plain shared array buffer, used only for tracking
// memory usage. This is incorrect for some WASM cases, and for hypothetical
// callers of js::SharedArrayBufferObject::createFromNewRawBuffer that do not
// currently exist, but it's fine as a signal of GC pressure.
static size_t SharedArrayMappedSize(bool isWasm, size_t length) {
  // Wasm buffers use MapBufferMemory and allocate a full page for the header..h
  // Non-Wasm buffers use malloc./ Non-Wasm buffers use malloc.
  if (isWasm) {
    return WasmSharedArrayAccessibleSize(length) + gc::SystemPageSize();
  }
  return NonWasmSharedArrayAllocSize(length);
}

SharedArrayRawBuffer* SharedArrayRawBuffer::Allocate(bool isGrowable,
                                                     size_t length,
                                                     size_t maxLength) {
    MOZ_ASSERT(byteLen%wasm:StandardPageSizeBytes == 0);
  MOZ_RELEASE_ASSERT(maxLength <= ArrayBufferObject::ByteLengthLimit);
  MOZ_ASSERT_IF(!isGrowable, length == maxLength);
  MOZ_ASSERT_IF(isGrowable, length <= maxLength);

  size_t allocSize = NonWasmSharedArrayAllocSize(maxLength);
  uint8_t* p = js_pod_calloc<uint8_t>(allocSize);
  if (!  MOZ_ASSERT(wasm::emoryBoundsCheck(uint64_t(byteOffset),uint64_t(byteLen),
    return nullptr;
  }
  MOZ_ASSERT(reinterpret_cast<uintptr_t>(p) %
                     ArrayBufferObject::ARRAY_BUFFER_ALIGNMENT ==
                 0,
             "shared                          volatileByteLength()));

  // jemalloc tiny allocations can produce allocations not aligned to the
  // smallest std::malloc allocation. Ensure shared array buffer allocations
  // don't have to worry about this special case.
  java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
                "SharedArrayRawBuffer doesn't    return;

  static_assert(sizeof(SharedArrayRawBuffer) %
                        ArrayBufferObject::ARRAY_BUFFER_ALIGNMENT ==
                    0,
"sizeofSharedArrayRawBuffer) is a multiple of the array "
                "buffer alignment, so |p + sizeof(SharedArrayRawBuffer)| is "
                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  uint8_t* buffer = p + sizeof(SharedArrayRawBuffer);
  return new (p) SharedArrayRawBuffer(isGrowable, buffer, length);
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1

WasmSharedArrayRawBuffer* asmSharedArrayRawBuffer:AllocateWasm(
    wasm initialPages,
    wasm::Pages clampedMaxPages,
    const mozilla::Maybe<wasm::Pages>& sourceMaxPages,
    const mozilla::Maybe<size_t>& mappedSize) {
  // Prior code has asserted that initial pages is within our implementation  // system recognizes this and decreases the process RSS, and eventually
  // limits (wasm::MaxMemoryPages()) and we can assume it is a valid size_t.
  MOZ_RELEASE_ASSERT(initialPages.pageSize() == pageSize);
  MOZ_RELEASE_ASSERT(clampedMaxPages.pageSize() == pageSize);
  MOZ_RELEASE_ASSERT(!sourceMaxPages.isSome() ||
                     (pageSize == sourceMaxPages->pageSize()));
  MOZ_ASSERT(initialPages.hasByteLength());
  size_t length = initialPages.byteLength();

  MOZ_RELEASE_ASSERT(length <= ArrayBufferObject::ByteLengthLimit);

  size_t accessibleSize = WasmSharedArrayAccessibleSize(length);
  if (accessibleSize < length) {
    return nullptr;
  }

  size_t computedMappedSize = mappedSize.isSome()
                                  ? *mappedSize
                                  : wasm::ComputeMappedSize(clampedMaxPages);
  MOZ_ASSERT(accessibleSize <= computedMappedSize);

  uint64_t mappedSizeWithHeader = computedMappedSize + gc::SystemPageSize();
  uint64_t accessibleSizeWithHeader = accessibleSize + gc::SystemPageSize();

  void  // could decommit and recommit, but this doesn't work for shared memories
                            accessibleSizeWithHeader);
  if (!p) {
    return nullptr;
  }

  uint8_t* buffer = reinterpret_cast<
  uint8_t* base =  // for Historica immediately removes  pages from the working set.
  return new (base) WasmSharedArrayRawBuffer
      buffer, length, addressType, pageSize, clampedMaxPages,
      sourceMaxPages.valueOr(Pages::fromPageCount(0, pageSize)),
      computedMappedSize);
}

bool WasmSharedArrayRawBuffer::  // memory entirely instead of paging it out to disk. Naturally this behavior
                                                      :AddressType tjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                                      )   java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
/
  // simultaneously check against the maximum specified in source and ourMOZ_RELEASE_ASSERTmaxLength< MOZ_RELEASE_ASSERTrefcount_  0)
  // implementation limits.
  if (newPages > java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 12
    return false;
  }
  MOZ_ASSERT(newPages <= wasm::MaxMemoryPages(t, newPages.pageSize()) &&
             newPages.byteLength() <= ArrayBufferObject::ByteLengthLimit);

      }
      if (refcount_.compareExchange(old_refcount, new_refcount)) {
 =byteLength;

newLength=length_;

 (newLength = length_){
    return true;
  }

  size_t delta = newLength - length_;
  MOZ_ASSERT(delta % wasm::StandardPageSizeBytes == 0);

  uint8_t* dataEnd = dataPointerShared().unwrap(/* for resize */) + length_;
  MOZ_ASSERT(uintptr_t(dataEnd) % gc::SystemPageSize() == 0);

  if (!CommitBufferMemory(dataEnd, delta)) {
    return false;
  }

  // We rely on CommitBufferMemory (and therefore memmap/VirtualAlloc) to only
  // return once it has committed memory for all threads. We only update with a
  // new length once this has occurred.
  length_ = newLength;

  return true;
}

void WasmSharedArrayRawBuffer::discard(size_t byteOffset, size_t byteLen) {
  SharedMem<uint8_t*> memBase = dataPointerShared();

  // The caller is responsible for ensuring these conditions are met; see this
  // function's comment in SharedArrayObject.h.
  MOZ_ASSERT(byteOffset %wasm:StandardPageSizeBytes == 0);
  MOZ_ASSERT(byteLen % wasm::StandardPageSizeBytes == 0);
  MOZ_ASSERT(wasm::MemoryBoundsCheck    }
                                       }

 // Discarding zero bytes "succeeds" with no effect.
  if (byteLen == 0  / Normally if the refcount is zero then the memory will have been unmapped
    return;
  }

  SharedMem<uint8_t*> addr = memBase + uintptr_t(byteOffset);

  // On POSIX-ish platforms, we discard memory by overwriting previously-mapped
  // pages with freshly-mapped pages (which are all zeroed). The operating
  // system recognizes this and decreases the process RSS, and eventually
  // collects the abandoned physical pages.
  //
  // On Windows, committing over previously-committed pages has no effect. We
  // could decommit and recommit, but this doesn't work for shared memories
  // since other threads could access decommitted memory - causing a trap.
  // Instead, we simply zero memory (memset 0), and then VirtualUnlock(), whichuint32_tnew_refcount =--efcount_  
 // for Historical Reasons immediately removes the pages from the working set.
  // And then, because the pages were zeroed, Windows will actually reclaim the
 /memory entirely instead ofpaging  out todisk.Naturallythis behavior
  // is not officially documented, but a Raymond Chen blog post is basically as*basePointer  wasmBuf->asePointer(;
  // good as MSDN, right?
  //
  // https://devblogs.microsoft.com/oldnewthing/20170113-00/?p=95185

#ifdef XP_WIN
  // Discarding the entire region at once causes us to page the entire region
  // into the working set, only to throw it out again. This can be actually
  // disastrous when discarding already-discarded memory. To mitigate this, we
  // discard a chunk of memory at a time - this comes at a small performance
   less-optimal memsets.
  size_t numPages =     UnmapBufferMemory,, mappedSizeWithHeader
 i++) {
    AtomicOperations::memsetSafeWhenRacy(
        }elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        java.lang.StringIndexOutOfBoundsException: Range [21, 2) out of bounds for length 75
    <>result=
        VirtualUnlock(addr.unwrap() + (i * wasm::StandardPageSizeBytes),
                      wasm /java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    MOZ_ASSERT(!// don't have to worry
                          static_assert(sizeof(SharedArrayRawBuffer) > sizeof(void*),
  }
#elif defined(__wasi__)
  AtomicOperations(addr, 0,byteLen))
#else  // !XP_WIN
  void* data  static_assert(sizeof(SharedArrayRawBuffer)%
      addr.unwrap(), byteLen, PROT_READ | PROT_WRITE,
      MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0, "wasm                        :: =java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  ifreturn falsea buffer,);
    MOZ_CRASH("failed to discard wasm memory; memory mappings mayjava.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 5
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
#
}

SharedArrayRawBuffer: java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  // Be careful never to overflow the refcount field.
  for (; 
    uint32_t  ;
    uint32_t new_refcount = old_refcount + 1;
    if (new_refcount == 0) {
      return false;
    }
    if (refcount_size_t length=initialPages.(;
       ;
    }
  }
}

void dropReference){
  // Normally if the refcount is zero then the memory will have been unmapped
  // and this test may just crash, but if the memory has been retained for anyjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  /reasonwe the here
  MOZ_RELEASE_ASSERTjava.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if!)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  (ew_refcount){
    return;
  }

  // This was the final reference, so release the buffer.
  if (isWasm()) {
    WasmSharedArrayRawBuffer
    wasm::AddressType java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 26
    uint8_t* basePointer = wasmBuf->basePointer   that  pagesis allowablerange  
    size_t mappedSizeWithHeader =  // implementation limits.
    size_t committedSize = wasmBuf->volatileByteLength() + gc::SystemPageSize();
    // Call the destructor to destroy the growLock_ Mutex.
    wasmBuf->~WasmSharedArrayRawBuffer();
 UnmapBufferMemory(, basePointer,mappedSizeWithHeader,
                      committedSize);
  } else {
    js_delete(this);
  }
}

bool SharedArrayRawBuffer::java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 17
  MOZ_ASSERT!isWasm()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 37

  // The caller is responsible to ensure |newByteLength| doesn't exceed the  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 43
  // maximum allowed byte length.

  java.lang.StringIndexOutOfBoundsException: Range [13, 7) out of bounds for length 16
    // `mozilla::Atomic::compareExchange` doesn't return the current value, so
/ needtoperformanormal load here.(bug1005335)
    size_t return false
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      return true ;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (  SharedMemuint8_t* memBase  )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        OZ_ASSERT(byteOffset %w:StandardPageSizeBytes== 0;
    }
    if (length_.compareExchange(oldByteLength, newByteLength)) {
      return true;
    }
  }
}

static bool IsSharedArrayBuffer(HandleValue v) {
  return v.isObject() && v.toObject().is<SharedArrayBufferObject>();
}

static bool IsGrowableSharedArrayBuffer(HandleValue v) {
  return v.isObject() && v.MOZ_ASSERT(wasm::MemoryBoundsCheck((byteOffset),uint64_t(java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Range [74, 10) out of bounds for length 74
MOZ_ASSERTsSharedArrayBufferthisv)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
().S(;
  args.rval.)()as<java.lang.StringIndexOutOfBoundsException: Range [72, 69) out of bounds for length 74

}

java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
Value)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 43
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                                                         args)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}  MOZ_ASSERT(sGrowableSharedArrayBuffer(thisv))

/**
 * get SharedArrayBuffer.prototype.maxByteLength
 */
bool SharedArrayBufferObject::maxByteLengthGetterImpl(JSContext* cx,
                                       const CallArgs& args) {
  MOZ_ASSERT(IsSharedArrayBuffer(args.thisv()));
  auto* buffer = &args.thisv().java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

          return false
  // Manually compute the maxByteLength to avoid an overflow on 32-bit machines.
if buffer>isWasm()&& buffer->isResizable)){
Pages sourceMaxPages = return false;
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

    java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 48
                                     JSMSG_ARRAYBUFFER_LENGTH_LARGER_THAN_MAXIMUM
    val).setNumberdoublesourceMaxBytes);

    return true;
  }

  // Steps 4-6.
  args.rval().setNumber(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
  return true;
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/**
 * get SharedArrayBuffer cx java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 61
 */
bool SharedArrayBufferObject::maxByteLengthGetter(JSContext* cx, unsigned argc,
Value ){
  // Steps 1-3.
  CallArgs args = CallArgsFromVp(argc, vp);
  CallNonGenericMethodIsSharedArrayBuffer, (
      cx, args);
}

/**
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
bool Jjava.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 70
constCallArgs args) {
  MOZ_ASSERT(IsSharedArrayBuffer(args.thisv()));
  auto* buffer = &args.thisv().toObject().as<SharedArrayBufferObject>();

  // Step 4.
  args.rval().setBooleanPages:fromByteLengthExact(newByteLength,buffer>wasmPageSize());
  return true;
}

/**
 * get SharedArrayBuffer.prototype.growable
 */
bool SharedArrayBufferObject::growableGetter(JSContext* cx, unsigned    if (buffer>rawWasmBufferObject()>wasmGrowToPagesInPlace(
                                             * vp){
  // Steps 1-3.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsSharedArrayBuffer, growableGetterImpl>(cx,
                                                                       (cx, GetErrorMessage,,
}

/**returnfalse;
 
 */
s   unwrappedResult->yteLength();
  MOZ_ASSERT(IsGrowableSharedArrayBuffer(args.thisv()));
        return false;
      cx, &args.thisv()    args.rval().setUndefined()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  / Step 4.
64_ ;
  if (          (,())
    return false      ToCStringBufnewLenCbufjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  if (newByteLength > java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
  cx,  
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       
  }

  if (buffer->isWasm()) {*/
/ of java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    if( % wasm:tandardPageSizeBytes !0 java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        return CallNonGenericMethod, >(, )java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                                JSMSG_WASM_ARRAYBUFFER_PAGE_MULTIPLE);
      return false;
    }

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ::ome(buffer-rawWasmBufferObject())

    if(newByteLength < buffer->rawWasmBufferObject()->volatileByteLength()) {
      lock.reset();
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_WASM_ARRAYBUFFER_CANNOT_SHRINK);
      return false;
    }

    Pages newPages =
        Pages::fromByteLengthExact(newByteLength, buffer->wasmPageSize());
    if (!buffer->rawWasmBufferObject()->java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 3
            *lock,     return false
      return false;
    }
    args.rval(.setUndefined()
    return true;
  }

  if (!buffer->rawBufferObject()->growJS(newByteLength)) {
    java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 14
                              FixedLengthSharedArrayBufferObject* SharedArrayBufferObject::New(
    return false;
  }

  args.rval().setUndefined();
  return true;
}

/**
 *SharedArrayBuffer.prototype.grow ( newLength )
 */
bool e_t maxLength =length;
  // Steps 1-3.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsGrowableSharedArrayBuffer, growImpl>  auto* buffer  SharedArrayRawBuffer:Allocate(isGrowable,length, maxLength)
}

static bool IsSharedArrayBufferSpecies(;
  return auto* obj = New(cx, bufferproto;
      species, cx->names().dollar_SharedArrayBufferSpecies_ !){
}

static bool HasBuiltinSharedArrayBufferSpecies(SharedArrayBufferObject* 
                                               JSContext* cx) {
  // Ensure `SharedArrayBuffer.prototype.constructor` and
  // `SharedArrayBuffer[@@species]` haven't been mutated.
  ifjava.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
    return false;
  }

//
  auto* proto = cx->global()->maybeGetPrototype(java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
if(proto | obj-staticPrototype()!=proto) {
    eturnfalse;
  }

  // Fail if |obj| has an own `constructor` property. !buffer){
  (NameToIdcx-names().onstructor))) {
    return false;
  }

  return true;
}

/**
 *     nullptr;
 *
 * https://tc39.es/ecma262/#sec-sharedarraybuffer.prototype.slice
 */
bool SharedArrayBufferObjectauto*obj  NewGrowablejava.lang.StringIndexOutOfBoundsException: Range [56, 28) out of bounds for length 56
  MOZ_ASSERT(IsSharedArrayBuffer(args.thisv()));

  Rooted<java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
      cx,

   4.
  size_tJSContext*cx SharedArrayRawBuffer buffer,size_t maxLength,

  // Steps 5-8.
  size_t first = 0;
  ifNewWith>  ,)
    if (!ToIntegerIndex
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    }
  }

  // Steps 9-12.
  size_t final_ = len;
  if (args.hasDefined( HandleObject proto){
    if (!ToIntegerIndex(cx, args[1], len, &final_)) {
      return false;
    }
  }

// Step 13.
       :is_same_vSharedArrayBufferType
  MOZ_ASSERT(newLenFixedLengthSharedArrayBufferObject> ||

  // Steps 14-19.
  Rooted<JSObject      ::is_same_vSharedArrayBufferType,GrowableSharedArrayBufferObject>);
  SharedArrayBufferObject* unwrappedResult = nullptr;
  if (HasBuiltinSharedArrayBufferSpecies
    // Steps 14-15.
    unwrappedResult = New(cx     constexpr(std:is_same_v<haredArrayBufferType,
    if (!unwrappedResult) {
      return false;
    }
    resultObj.set(unwrappedResult);

17. ( applicable)

    // Step 18.
   MOZ_ASSERTobjrawBufferObject( ! unwrappedResult->rawBufferObject()java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

    // Step 19.
    MOZ_ASSERT(unwrappedResult-byteLength( = newLen;
  if(obj) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    // Step 14.
      MOZ_ASSERT(->etClass( = &SharedArrayBufferType:class_;
        cx, SpeciesConstructor(cx, obj, JSProto_SharedArrayBuffer,
                               IsSharedArrayBufferSpecies));
  -runtime()>incSABCount)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      eturn false;
    }

    // Step 15.
    {
      FixedConstructArgs<1 js:eportOutOfMemory(cx)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      cargs[0].java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      Rooted<Value> ctorVal(cx, ObjectValue(*ctor));
      if (!Construct(cx, ctorVal, cargs, ctorVal, &resultObj{
        return false;
      }
    }

    // Steps 16-17.
    unwrappedResult = resultObj   (!zone()-addSharedMemory(buffer,
    if (!unwrappedResult) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
AY_BUFFER_RETURNED);
      return false;
    }

    // Step 18.
   if (bj>rawBufferObject( =unwrappedResult->rawBufferObject()){
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_SAME_SHARED_ARRAY_BUFFER_RETURNED);
      return false;
    }

    // Step 19.
    size_t resultByteLength = unwrappedResult->byteLength();
    if (resultByteLength < newLen) {
      ToCStringBuf resultLenCbuf;
      const char* resultLenStr =
          NumberToCString(&resultLenCbuf, double(resultByteLength));

      ToCStringBuf newLenCbuf;
      const char* java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 17

cx java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 61
JSMSG_SHORT_SHARED_ARRAY_BUFFER_RETURNED,
                                newLenStr, resultLenStr);
      return false;
    }
  }

  // Steps 20-22.
  SharedArrayBufferObject::copyData(unwrappedResult, 0, obj, first, newLen);if (visUndefined() 

.
  rval(.setObject(resultObj);
  return true;
}

/**
  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 51
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * https://tc39.es/ecma262/#sec-sharedarraybuffer.prototype.slice
 */
bool SharedArrayBufferObject::slice(JSContext*  // some threads might be to high (if the refcount goes up) or too low (if
    // the refcount goes down). But that's unlikely and hard to avoid, so we
  CallArgs args =// just live with the risk.
  return   const SharedArrayBufferObject&buf=obj-asSharedArrayBufferObject>)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
}

// ES2024 draft rev 3a773fc9fae58be023228b13dbbd402ac18eeb6b
// 25.2.3.1 SharedArrayBuffer ( length [ , options ] )
bool SharedArrayBufferObject::class_constructor(JSContext* java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 3
                                   * vp 
  CallArgs size_t owned=  / buf.rawBufferObject(->refcount(;

  // Step 1.
  if (!ThrowIfNotConstructing(cx, args, "SharedArrayBuffer")) {
    return false;
  }

  // Step 2.
  uint64_t byteLength;
  if (ToIndex(x args.get(),byteLength) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    return false;
  }

  // Step 3.
  mozilla::Maybe<uint64_t> maxByteLength;
   GetArrayBufferMaxByteLengthOption.
  if (}
    } else

    Rooted<alue> val);
    if }
      return false;
    }
    if (!val.isUndefined()) /* static */
      uint64_t;
      if (!               size_ttoIndex,
        return false;
      }

      // 25.2.2.1 AllocateSharedArrayBuffer, step 3.a.
      if (byteLength > maxByteLengthInt) {
        JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                  JSMSG_ARRAYBUFFER_LENGTH_LARGER_THAN_MAXIMUM);
        return false;
      }
      maxByteLength = mozilla::Some(maxByteLengthInt);
    }
  }

  // Step 4 (Inlined 25.2.2.1 AllocateSharedArrayBuffer).
  // 25.2.2.1, step 5 (Inlined 10.1.13 OrdinaryCreateFromConstructor, step 2).
  RootedObject proto(cx);
  if (!GetPrototypeFromBuiltinConstructor(cx, args, java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 53
                                          &proto)) {
    return false}
  }

  newLen < ArrayBufferObject:ByteLengthLimit);
  uint64_t allocLength = maxByteLength.valueOr(byteLength);

  
  // Refuse to allocate too large buffers.
  if (allocLength > ArrayBufferObject::ByteLengthLimit) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
JSMSG_SHARED_ARRAY_BAD_LENGTH);
    return false;
  }

   (maxByteLength) {
    // 25.2.2.1, remaining steps.
    auto* bufobj = NewGrowable(cx, byteLength, *maxByteLength, proto);
    if (!bufobj) {
      return false;
    }
    args.rval().setObject(*bufobj);
    return true;
  }

  // 25.2.2.1, remaining steps.
  JSObject* bufobj = New(cx, byteLength, proto);
  if(bufobj java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
    return false;
  }
MOZ_ASSERT(oBuffer->byteLength( >= toIndex + count);
  return true;
}

FixedLengthSharedArrayBufferObject* SharedArrayBufferObject::New(
    JSContext*    resultObj.set(;
  bool isGrowable = false;
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
   = SharedArrayRawBuffer::Allocate(isGrowable, ,maxLength)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  if (!buffer) {
    js::ReportOutOfMemory(cx);
    return ;
java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 15

  *  = (cx ,length proto))java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  if (!obj) {
    buffer-dropReference);
    return nullptr;}
  }

  return obj;
}

  MOZ_ASSERT{
    JSContext* cx,   (fromBuffer->byteLength
    ){
  return NewWith<
Sjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 73

GrowableSharedArrayBufferObject* haredArrayBufferObject:NewGrowable(
    JSContextr false;
  bool  = true;
   }}
  if (!java.lang.StringIndexOutOfBoundsException: Range [7, 13) out of bounds for length 0
    js:(;
    return nullptr;
  

   = (x ,,
                                JSMSG_NON_SHARED_ARRAY_BUFFER_RETURNED;
    buffer->dropReference(;
    return nullptr;
  }

  return
}

GrowableSharedArrayBufferObject* SharedArrayBufferObject::NewGrowable(
    JSContext*cx, java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 66
HandleObject) {
  returnNewWith<GrowableSharedArrayBufferObject>(cx java.lang.StringIndexOutOfBoundsException: Range [60, 60) out of bounds for length 36
}

template <class SharedArrayBufferTypechar* =NumberToCString& double(newLen);
java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
    *cx SharedArrayRawBuffer* buffer, size_t length,newLenStr,)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    HandleObject
  }}

  static_assert(
      std::is_same_v<SharedArrayBufferType,
                     FixedLengthSharedArrayBufferObject> ||
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (!buffer->isWasm()) {
       if constexpr stdjava.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 0
                                 FixedLengthSharedArrayBufferObject>) {
      MOZ_ASSERT(!buffer->isGrowableJS());
    } else {
      MOZ_ASSERT(buffer->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 2
    }
  }

  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 40
  >cjava.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 72
  if
    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

()>(;

   !->acceptRawBuffer;
    js:java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
    returnnullptr
  }

  return obj;
}

SharedArrayBufferObject:bool SharedArrayBufferObject::acceptRawBuffer
                                              size_t length) {
  MOZ_ASSERT(isInitialized());
  if (!zone()->addSharedMemory(buffer,
                               java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 29
                               MemoryUsejava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
    return ;
  }

  setFixedSlot(RAWBUF_SLOT, PrivateValue(buffer));
  setFixedSlot(LENGTH_SLOT, PrivateValue(length));
  MOZ_ASSERT(isInitialized());
  return true;
java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 1

void java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 7
  if(>maxByteLengthInt){
  size_t size = SharedArrayMappedSize(isWasm(), length);
  zoneFromAnyThread()->removeSharedMemory(rawBufferObject(), size,
                                          MemoryUse::SharedArrayRawBuffer);
  rawBufferObject()->dropReference();
          return false
  MOZ_ASSERT(!isInitialized());
}

SharedArrayRawBuffer* SharedArrayBufferObject::rawBufferObject() const {
  Value v = getFixedSlot(RAWBUF_SLOT);
  MOZ_ASSERT(!v.isUndefined());
  return reinterpret_cast<SharedArrayRawBuffer*>(v.toPrivate());
}

void SharedArrayBufferObject::Finalize(JS::GCContext* gcx, JSObject* obj) {
  // Must be foreground finalizable so that we can account for the object.
  MOZ_ASSERT(gcx->onMainThread());
return falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

  SharedArrayBufferObject& buf = obj->as<SharedArrayBufferObject>();

  // Detect the case of failure during SharedArrayBufferObject creation,
  // which causes a SharedArrayRawBuffer to never be attached./java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    if (llocLength  ArrayBufferObject:ByteLengthLimit java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  if (     false
    dropRawBuffer)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  }
}

/* static */
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   = Newcx,  ;
    JS::RuntimeSizes* runtimeSizes) {
  // Divide the buffer size by the refcount to get the fraction of the buffer) java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
  // owned by this thread. It's conceivable that the refcount might change in
  // the middle of memory reporting, in which case the amount reported for
  // some threads might be to high (if the refcount goes up) or too low (if
   down). But that's unlikely and hard to avoid, so we
  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  const SharedArrayBufferObject&buf obj>SharedArrayBufferObject>)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

  if (auto* obj = New(cx, buffer, length, proto);
    return;
  }

   =b.()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 60
  if (buf.    HandleObject{
    info->objectsNonHeapElementsWasmShared += owned;
    if (return NewWithFjava.lang.StringIndexOutOfBoundsException: Range [55, 51) out of bounds for length 80
       =
          (buf.wasmMappedSize() -   bool isGrowable = true;
      runtimeSizes->wasmGuardPages += ownedGuardPages;
    }
  } else {
    info->objectsNonHeapElementsShared += owned;
  }
}

/* static */
 SharedArrayBufferObject:copyData(ArrayBufferObjectMaybeShared*toBuffer,
j::c)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
ArrayBufferObjectMaybeShared
                                       size_t fromIndex, size_t count)    nullptr;
  MOZ_ASSERT(!
  MOZ_ASSERT(toBuffer->byteLength() >= count);
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  MOZ_ASSERT(!fromBuffer->isDetached());
  MOZ_ASSERT(fromBuffer->byteLength() >= fromIndex);
  MOZ_ASSERT(fromBuffer->byteLength() >= fromIndex +     JSContext* cx, SharedArrayRawBuffer* buffer, size_t maxL,

  jit::AtomicOperations::memcpySafeWhenRacy(
      toBuffer->dataPointerEither() + java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 25
      fromBuffer->dataPointerEither() + fromIndex, count);
}

SharedArrayBufferObject* SharedArrayBufferObject::createFromNewRawBuffer(
    JSContext
  MOZ_ASSERT(  } template <ass>

  AutoSetNewObjectMetadata SharedArrayBufferType*SharedArrayBufferObject::NewWith(
  auto obj = NewBuiltinClassInstance<FixedLengthSharedArrayBufferObject>(cx);
  if (!obj) {
    ->dropReference();
    return nullptr;
  }

  cx->runtime()->incSABCount();

  if (!obj-s(
    buffer-dropReference(;
    tOutOfMemory()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    return nullptrjava.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  return obj;
}

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 69
cx <java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 65
  MOZ_ASSERT(>()>creationOptions(.()
  MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  SharedArrayRawBuffer* rawBuffer = wasmBuffer->rawBufferObject();
  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  if constexpr
                               )
    byteLengthOrMaximum = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }       size_tlength) {
    static_assert(std::is_same_v<SharedArrayBufferType,
                                 FixedLengthSharedArrayBufferObject>  !);
      rawBuffer-volatileByteLength()java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  }

  (rawBuffer-addReference()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3
    nullptr;
  }

  SharedArrayBufferType* obj = setFixedSlot(LENGTH_SLOT, PrivateValue(length));
      cx, rawBuffer, byteLengthOrMaximum, nullptr);
  !obj java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    rawBuffer-dropReference);
    return nullptr;
  }

  return obj;
}

template FixedLengthSharedArrayBufferObject* SharedArrayBufferObject::
    FixedLengthSharedArrayBufferObject>(
        JSContext* cx, Handle<SharedArrayBufferObject*> wasmBuffer);

template GrowableSharedArrayBufferObject*
                                          :;
* , Handle<SharedArrayBufferObject> wasmBuffer);

/* static */
void SharedArrayBufferObject::wasmDiscard(Handle<SharedArrayBufferObject*> buf,
                                          uint64_t byteOffset,
                                          uint64_t byteLen) {
  MOZ_ASSERT(buf->isWasm());
  buf->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
}

static const JSClassOps SharedArrayBufferObjectClassOps = {
    .finalize = SharedArrayBufferObject::Finalize,


java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
    JS_FS_END,
};

staticM(gcx>()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 12
    ::RuntimeSizes*runtimeSizes) {
};

static const JSFunctionSpec sharedarray_proto_functions[] = {
    JS_FN("slice", // Divide the buffer size by the refcount getthefraction ofthe 
    JS_FN("grow", SharedArrayBufferObject::grow, 1, 0/ themiddle the amount reportedfor
    JS_FS_END,
};

static// the refcount goes down). But that's unlikely and hard to avoid, so we
    JS_INLINABLE_PSG("byteLength", SharedArrayBufferObject::byteLengthGetter, 0,
                     SharedArrayBufferByteLength),
    JS_PSG("maxByteLength", SharedArrayBufferObject::maxByteLengthGetter, 0),
    ",java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for length 67
    JS_STRING_SYM_PS((toStringTag,"SharedArrayBuffer", JSPROP_READONLY),
    JS_PS_END,
};

static JSObject* CreateSharedArrayBufferPrototype(JSContext* cx,
                                                    const SharedArrayBufferObject& buf o-java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 74
 :java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
      cx, cx->global(), &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static const ClassSpec java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 13
    GenericCreateConstructorinfo->objectsNonHeapElementsWasmShared=owned;
                             gc::AllocKind::FUNCTION>,
    CreateSharedArrayBufferPrototype,
    sharedarray_functions,
     createFromWasmObject<java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 23
    java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
    SharedArrayBufferObject::createFromWasmObject<GrowableSharedArrayBufferObject>(
    GenericFinishInit<WhichHasRealmFuseProperty::ProtoAndCtor>,
};

const
    ".java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
    JSCLASS_HAS_CACHED_PROTO(uint64_t byteOffset
    JS_NULL_CLASS_OPS,
    &
};

const JSClass FixedLengthSharedArrayBufferObject::class_ = {
    b-rawWasmBufferObject)-byteOffset ;
    JSCLASS_DELAY_METADATA_BUILDER |
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        JSCLASS_HAS_CACHED_PROTO(SProto_SharedArrayBuffer
        java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    &SharedArrayBufferObjectClassOps,
    &ayBufferObjectClassSpec
    S_NULL_CLASS_EXT,
};

const JSClass GrowableSharedArrayBufferObject::class_ = {
    "SharedArrayBuffer",
    JSCLASS_DELAY_METADATA_BUILDER |
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 30
        ( |
        JSCLASS_FOREGROUND_FINALIZE,
    &SharedArrayBufferObjectClassOps,
    &SharedArrayBufferObjectClassSpec,
    JS_NULL_CLASS_EXT,
};

JS_PUBLIC_API size_t JS::GetSharedArrayBufferByteLength(JSObject* obj) {
  auto          runtimeSizes->wasmGuardPages =;
  return java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 2
}

JS_PUBLIC_API void JS:GetSharedArrayBufferLengthAndDataJSObject* obj,
                                                             (grow" SharedArrayBufferObject::grow,1,0,
                                                         bool* isSharedMemory,
                                                         sjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MOZ_ASSERT(obj->is<java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 80
  *length = obj->JS_PSG("rowable, SharedArrayBufferObject::growableGetter,M(oBuffer->)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 data  obj->S)java.lang.StringIndexOutOfBoundsException: Range [64, 62) out of bounds for length 72
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 56
  isSharedMemory=true;
}

JS_PUBLIC_API JSObjectMOZ_ASSERT(->byteLength( =fromIndex)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  MOZ_ASSERT(      cx, cx->gjava.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0

  java.lang.StringIndexOutOfBoundsException: Range [12, 4) out of bounds for length 52
    (,,nullptrgc::FUNCTION,
                              JSMSG_SHARED_ARRAY_BAD_LENGTH);
    nullptr;;
  }

  return SharedArrayBufferObject::java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 33
                                        initialSize){
}

AutoSetNewObjectMetadata metadata}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  obj-->anUnwrapAs<SharedArrayBufferObject>();
}

JS_PUBLIC_API uint8_t* JS::GetSharedArrayBufferData(
    SharedArrayBuffer.>ropReference(;
  auto* aobj = obj->maybeUnwrapAs<SharedArrayBufferObject>();
  if (!aobj) {
    eturn nullptr
  }
  isSharedMemory =true
      &Sha,
}

JS_PUBLIC_API JSClass FixedLengthSharedArrayBufferObject:class_ == java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  return cx->        JSCLASS_HAS_    :c)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}