ECMA-262 (12th Edition) ECMAScript 2021 Language Specification - page 55

be the Element Size value specified in

(

buffer

) is

true

, throw a

TypeError

exception.

9. Let

viewOffset

view

.[[ByteOffset]].

10. Let

viewSize

view

.[[ByteLength]].

11. Let

elementSize

for Element Type

type

12. If

getIndex

elementSize

viewSize

, throw a

RangeError

exception.

13. Let

bufferIndex

getIndex

viewOffset

14. Return

SetValueInBuffer

(

buffer

bufferIndex

type

numberValue

false

Unordered

isLittleEndian

The DataView

%DataView%

is the initial value of the

"DataView"

property of the

global object

creates and initializes a new DataView object when called as a

is not intended to be called as a function and will throw an exception when called in that manner.
is designed to be subclassable. It may be used as the value of an

extends

clause of a class definition. Subclass

constructors that intend to inherit the specified DataView behaviour must include a

super

call to the

DataView

to create and initialize subclass instances with the internal state necessary to support the

DataView.prototype

built-in methods.

When the

DataView

function is called with at least one argument

buffer

, the following steps are taken:

1. If NewTarget is

undefined

, throw a

TypeError

exception.

(

buffer

, [[ArrayBufferData]]).

3. Let

offset

be ?

ToIndex

byteOffset

4. If

OrdinaryCreateFromConstructor

(

buffer

) is

true

, throw a

TypeError

exception.

5. Let

bufferByteLength

buffer

.[[ArrayBufferByteLength]].

6. If

offset

bufferByteLength

, throw a

RangeError

exception.

7. If

byteLength

undefined

, then

a. Let

viewByteLength

bufferByteLength

offset

8. Else,

a. Let

viewByteLength

be ?

ToIndex

(

byteLength

b. If

offset

viewByteLength

bufferByteLength

, throw a

RangeError

exception.

9. Let

be ?

(NewTarget,

"%DataView.prototype%"

, « [[DataView]],

[[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]] »).

10. If

(

buffer

) is

true

, throw a

TypeError

exception.

11. Set

.[[ViewedArrayBuffer]] to

buffer

12. Set

.[[ByteLength]] to

viewByteLength

13. Set

.[[ByteOffset]] to

offset

14. Return

The DataView

DataView prototype object

25.3.2 The DataView Constructor

25.3.2.1 DataView (

buffer

[ ,

byteOffset

[ ,

byteLength

] ] )

25.3.3 Properties of the DataView Constructor

720

has a [[Prototype]] internal slot whose value is

%Function.prototype%

has the following properties:

The initial value of

DataView.prototype

is the

This property has the attributes { [[Writable]]:

false

, [[Enumerable]]:

false

, [[Configurable]]:

false

The

DataView prototype object

%DataView.prototype%

has a [[Prototype]] internal slot whose value is

%Object.prototype%

is an

ordinary object

does not have a [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], or [[ByteOffset]] internal slot.

DataView.prototype.buffer

is an

accessor property

whose set accessor function is

undefined

. Its get

accessor function performs the following steps:

1. Let

be the

this

value.

(

, [[DataView]]).

has a [[ViewedArrayBuffer]] internal slot.

4. Let

buffer

.[[ViewedArrayBuffer]].

5. Return

buffer

DataView.prototype.byteLength

is an

accessor property

whose set accessor function is

undefined

. Its get

accessor function performs the following steps:

1. Let

be the

this

value.

(

, [[DataView]]).

has a [[ViewedArrayBuffer]] internal slot.

4. Let

buffer

.[[ViewedArrayBuffer]].

5. If

(

buffer

) is

true

, throw a

TypeError

exception.

6. Let

size

.[[ByteLength]].

7. Return

size

DataView.prototype.byteOffset

is an

accessor property

whose set accessor function is

undefined

. Its get

accessor function performs the following steps:

1. Let

be the

this

value.

(

, [[DataView]]).

25.3.3.1 DataView.prototype

25.3.4 Properties of the DataView Prototype Object

25.3.4.1 get DataView.prototype.buffer

25.3.4.2 get DataView.prototype.byteLength

25.3.4.3 get DataView.prototype.byteOffset

721

has a [[ViewedArrayBuffer]] internal slot.

4. Let

buffer

.[[ViewedArrayBuffer]].

5. If

(

buffer

) is

true

, throw a

TypeError

exception.

6. Let

offset

.[[ByteOffset]].

7. Return

offset

The initial value of

DataView.prototype.constructor

%DataView%

When the

getBigInt64

method is called with argument

byteOffset

and optional argument

littleEndian

, the

following steps are taken:

1. Let

be the

this

value.

(

byteOffset

littleEndian

BigInt64

When the

getBigUint64

method is called with argument

byteOffset

and optional argument

littleEndian

, the

following steps are taken:

1. Let

be the

this

value.

(

byteOffset

littleEndian

BigUint64

When the

getFloat32

method is called with argument

byteOffset

and optional argument

littleEndian

, the following

steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

(

byteOffset

littleEndian

Float32

When the

getFloat64

method is called with argument

byteOffset

and optional argument

littleEndian

, the following

steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

(

byteOffset

littleEndian

Float64

When the

getInt8

method is called with argument

byteOffset

, the following steps are taken:

1. Let

be the

this

value.

25.3.4.4 DataView.prototype.constructor

25.3.4.5 DataView.prototype.getBigInt64 (

byteOffset

[ ,

littleEndian

] )

25.3.4.6 DataView.prototype.getBigUint64 (

byteOffset

[ ,

littleEndian

] )

25.3.4.7 DataView.prototype.getFloat32 (

byteOffset

[ ,

littleEndian

] )

25.3.4.8 DataView.prototype.getFloat64 (

byteOffset

[ ,

littleEndian

] )

25.3.4.9 DataView.prototype.getInt8 (

byteOffset

)

722

(

byteOffset

true

Int8

When the

getInt16

method is called with argument

byteOffset

and optional argument

littleEndian

, the following

steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

(

byteOffset

littleEndian

Int16

When the

getInt32

method is called with argument

byteOffset

and optional argument

littleEndian

, the following

steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

(

byteOffset

littleEndian

Int32

When the

getUint8

method is called with argument

byteOffset

, the following steps are taken:

1. Let

be the

this

value.

(

byteOffset

true

Uint8

When the

getUint16

method is called with argument

byteOffset

and optional argument

littleEndian

, the following

steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

(

byteOffset

littleEndian

Uint16

When the

getUint32

method is called with argument

byteOffset

and optional argument

littleEndian

, the following

steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

(

byteOffset

littleEndian

Uint32

When the

setBigInt64

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

the following steps are taken:

25.3.4.10 DataView.prototype.getInt16 (

byteOffset

[ ,

littleEndian

] )

25.3.4.11 DataView.prototype.getInt32 (

byteOffset

[ ,

littleEndian

] )

25.3.4.12 DataView.prototype.getUint8 (

byteOffset

)

25.3.4.13 DataView.prototype.getUint16 (

byteOffset

[ ,

littleEndian

] )

25.3.4.14 DataView.prototype.getUint32 (

byteOffset

[ ,

littleEndian

] )

25.3.4.15 DataView.prototype.setBigInt64 (

byteOffset

value

[ ,

littleEndian

] )

723

1. Let

be the

this

value.

byteOffset

littleEndian

BigInt64

value

When the

setBigUint64

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

the following steps are taken:

1. Let

be the

this

value.

byteOffset

littleEndian

BigUint64

value

When the

setFloat32

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

, the

following steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

byteOffset

littleEndian

Float32

value

When the

setFloat64

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

, the

following steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

byteOffset

littleEndian

Float64

value

When the

setInt8

method is called with arguments

byteOffset

and

value

, the following steps are taken:

1. Let

be the

this

value.

byteOffset

true

Int8

value

When the

setInt16

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

, the

following steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

byteOffset

littleEndian

Int16

value

When the

setInt32

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

, the

following steps are taken:

25.3.4.16 DataView.prototype.setBigUint64 (

byteOffset

value

[ ,

littleEndian

] )

25.3.4.17 DataView.prototype.setFloat32 (

byteOffset

value

[ ,

littleEndian

] )

25.3.4.18 DataView.prototype.setFloat64 (

byteOffset

value

[ ,

littleEndian

] )

25.3.4.19 DataView.prototype.setInt8 (

byteOffset

value

)

25.3.4.20 DataView.prototype.setInt16 (

byteOffset

value

[ ,

littleEndian

] )

25.3.4.21 DataView.prototype.setInt32 (

byteOffset

value

[ ,

littleEndian

] )

724

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

byteOffset

littleEndian

Int32

value

When the

setUint8

method is called with arguments

byteOffset

and

value

, the following steps are taken:

1. Let

be the

this

value.

byteOffset

true

Uint8

value

When the

setUint16

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

, the

following steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

byteOffset

littleEndian

Uint16

value

When the

setUint32

method is called with arguments

byteOffset

and

value

and optional argument

littleEndian

, the

following steps are taken:

1. Let

be the

this

value.

2. If

littleEndian

is not present, set

littleEndian

false

DataView prototype object

byteOffset

littleEndian

Uint32

value

The initial value of the

@@toStringTag

property is the String value

"DataView"

This property has the attributes { [[Writable]]:

false

, [[Enumerable]]:

false

, [[Configurable]]:

true

DataView instances are ordinary objects that inherit properties from the

. DataView

instances each have [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], and [[ByteOffset]] internal slots.

NOTE

The Atomics object:

The value of the [[DataView]] internal slot is not used within this specification. The simple
presence of that internal slot is used within the specification to identify objects created using the
DataView

25.3.4.22 DataView.prototype.setUint8 (

byteOffset

value

)

25.3.4.23 DataView.prototype.setUint16 (

byteOffset

value

[ ,

littleEndian

] )

25.3.4.24 DataView.prototype.setUint32 (

byteOffset

value

[ ,

littleEndian

] )

25.3.4.25 DataView.prototype [ @@toStringTag ]

25.3.5 Properties of DataView Instances

25.4 The Atomics Object

725

%Atomics%

is the initial value of the

"Atomics"

property of the

global object

is an

ordinary object

has a [[Prototype]] internal slot whose value is

%Object.prototype%

does not have a [[Construct]] internal method; it cannot be used as a

with the

new

operator.

does not have a [[Call]] internal method; it cannot be invoked as a function.

The Atomics object provides functions that operate indivisibly (atomically) on shared memory array cells as well as
functions that let agents wait for and dispatch primitive events. When used with discipline, the Atomics functions
allow multi-

programs that communicate through shared memory to execute in a well-understood order even on

parallel CPUs. The rules that govern shared-memory communication are provided by the

memory model

, defined

below.

NOTE

The abstract operation ValidateIntegerTypedArray takes argument

typedArray

and optional argument

waitable

Boolean). It performs the following steps when called:

1. If

waitable

is not present, set

waitable

false

2. Let

buffer

ValidateTypedArray

(

typedArray

3. Let

typeName

typedArray

.[[TypedArrayName]].

4. Let

type

be the Element Type value in

IsUnclampedIntegerElementType

for

typeName

5. If

waitable

true

, then

a. If

typeName

is not

"Int32Array"

"BigInt64Array"

, throw a

TypeError

exception.

6. Else,

a. If !

type

) is

false

and !

IsBigIntElementType

(

type

) is

false

, throw a

TypeError

exception.

7. Return

buffer

The abstract operation ValidateAtomicAccess takes arguments

typedArray

and

requestIndex

. It performs the following

steps when called:

typedArray

is an Object that has a [[ViewedArrayBuffer]] internal slot.

2. Let

length

typedArray

.[[ArrayLength]].

3. Let

accessIndex

ToIndex

(

requestIndex

be the Element Size value specified in

accessIndex

≥

5. If

accessIndex

≥

length

, throw a

RangeError

exception.

6. Let

arrayTypeName

typedArray

.[[TypedArrayName]].

7. Let

elementSize

arrayTypeName

8. Let

offset

typedArray

.[[ByteOffset]].

9. Return (

accessIndex

elementSize

) +

offset

For informative guidelines for programming and implementing shared memory in ECMAScript,
please see the notes at the end of the

memory model

section.

25.4.1 Abstract Operations for Atomics

25.4.1.1 ValidateIntegerTypedArray (

typedArray

[ ,

waitable

] )

25.4.1.2 ValidateAtomicAccess (

typedArray

requestIndex

)

726

WaiterList

is a semantic object that contains an ordered list of those agents that are waiting on a location (

block

) in

shared memory;

block

is a

Shared Data Block

and

a byte offset into the memory of

block

. A WaiterList object also

optionally contains a

denoting the previous leaving of its critical section.

Initially a WaiterList object has an empty list and no

The

agent cluster

has a store of WaiterList objects; the store is indexed by (

block

). WaiterLists are

a lookup in the store of WaiterLists by (

-independent:

block

) will result in the same WaiterList object in any

Each WaiterList has a

critical section

that controls exclusive access to that WaiterList during evaluation. Only a single

may enter a WaiterList's critical section at one time. Entering and leaving a WaiterList's critical section is

controlled by the

. Operations on a WaiterList—

adding and removing waiting agents, traversing the list of agents, suspending and notifying agents on the list, setting
and retrieving the

—may only be performed by agents that have entered the WaiterList's critical

section.

The abstract operation GetWaiterList takes arguments

block

Shared Data Block

) and

(a non-negative

integer

). It

performs the following steps when called:

block

and

+ 3 are valid byte offsets within the memory of

block

is divisible by 4.

4. Return the

that is referenced by the pair (

block

The abstract operation EnterCriticalSection takes argument

). It performs the following steps when

called:

: The calling

is not in the

2. Wait until no

for

, then enter the

for

(without allowing any

other

to enter).

3. If

has a

a. NOTE: A

has been entered at least once has a

set by

b. Let

execution

be the [[CandidateExecution]] field of the

c. Let

eventsRecord

be the

Agent Events Record

execution

.[[EventsRecords]] whose [[AgentSignifier]] is

().

d. Let

entererEventList

eventsRecord

.[[EventList]].

e. Let

enterEvent

be a new

f. Append

enterEvent

entererEventList

g. Let

leaveEvent

be the

h. Append (

leaveEvent

enterEvent

) to

eventsRecord

.[[AgentSynchronizesWith]].

EnterCriticalSection has

contention

when an

attempting to enter the

must wait for another

to leave it. When there is no contention, FIFO order of EnterCriticalSection calls is observable. When there is
contention, an implementation may choose an arbitrary order but may not cause an

to wait indefinitely.

25.4.1.3 GetWaiterList (

block

)

25.4.1.4 EnterCriticalSection (

)

727

The abstract operation LeaveCriticalSection takes argument

). It performs the following steps when

called:

: The calling

2. Let

execution

be the [[CandidateExecution]] field of the calling surrounding's

3. Let

eventsRecord

be the

Agent Events Record

execution

.[[EventsRecords]] whose [[AgentSignifier]] is

().

4. Let

leaverEventList

eventsRecord

.[[EventList]].

5. Let

leaveEvent

be a new

6. Append

leaveEvent

leaverEventList

7. Set the

leaveEvent

8. Leave the

for

The abstract operation AddWaiter takes arguments

) and

(an

is not on the list of waiters in any

signifier). It performs the

following steps when called:

: The calling

3. Add

to the end of the list of waiters in

The abstract operation RemoveWaiter takes arguments

) and

(an

signifier). It performs the

following steps when called:

: The calling

is on the list of waiters in

3. Remove

from the list of waiters in

The abstract operation RemoveWaiters takes arguments

) and

∞

). It

performs the following steps when called:

: The calling

2. Let

3. Let

be a reference to the list of waiters in

4. Repeat, while

> 0 and

is not an empty

a. Let

be the first waiter in

b. Add

to the end of

c. Remove

from

d. If

is finite, set

- 1.

5. Return

25.4.1.5 LeaveCriticalSection (

)

25.4.1.6 AddWaiter (

)

25.4.1.7 RemoveWaiter (

)

25.4.1.8 RemoveWaiters (

)

25.4.1.9 SuspendAgent (

timeout

)

728

The abstract operation SuspendAgent takes arguments

(an

signifier), and

timeout

(a non-

negative

integer

). It performs the following steps when called:

: The calling

is equivalent to

().

is on the list of waiters in

AgentCanSuspend

() is

true

5. Perform

(

) and suspend

for up to

timeout

milliseconds, performing the combined

operation in such a way that a notification that arrives after the

is exited but before the

suspension takes effect is not lost.

can notify either because the timeout expired or because it was notified

explicitly by another

calling

NotifyWaiter

(

), and not for any other reasons at all.

6. Perform

EnterCriticalSection

(

7. If

was notified explicitly by another

The abstract operation AtomicReadModifyWrite takes arguments

calling

NotifyWaiter

(

), return

true

8. Return

false

The abstract operation NotifyWaiter takes arguments

signifier). It performs the

following steps when called:

: The calling

2. Notify the

NOTE

modification function

takes two

of byte values arguments and returns a

of byte values. This operation

atomically loads a value, combines it with another value, and stores the result of the combination. It returns the
loaded value. It performs the following steps when called:

1. Let

buffer

(

typedArray

2. Let

indexedPosition

(

typedArray

index

3. Let

arrayTypeName

typedArray

.[[TypedArrayName]].

4. If

typedArray

.[[ContentType]] is

BigInt

, let

value

5. Otherwise, let

value

)).

6. If

(

buffer

) is

true

, throw a

TypeError

exception.

7. NOTE: The above check is not redundant with the check in

because the call to

on the preceding lines can have arbitrary side effects, which could cause the

buffer to become detached.

8. Let

elementType

be the Element Type value in

GetModifySetValueInBuffer

arrayTypeName

9. Return

(

buffer

indexedPosition

elementType

The abstract operation ByteListBitwiseOp takes arguments

(a sequence of Unicode code points),

xBytes

The embedding may delay notifying

, e.g. for resource management reasons, but

must

eventually be notified in order to guarantee forward progress.

25.4.1.10 NotifyWaiter (

)

25.4.1.11 AtomicReadModifyWrite (

typedArray

index

value

)

25.4.1.12 ByteListBitwiseOp (

xBytes

yBytes

)

729

byte values), and

yBytes

of byte values). The operation atomically performs a bitwise operation on all byte

values of the arguments and returns a

of byte values. It performs the following steps when called:

, or

xBytes

and

yBytes

have the same number of elements.

3. Let

result

be a new empty

4. Let

be 0.

5. For each element

xByte

xBytes

, do

a. Let

yByte

yBytes

[

b. If

, let

resultByte

be the result of applying the bitwise AND operation to

xByte

and

yByte

c. Else if

, let

resultByte

be the result of applying the bitwise exclusive OR (XOR) operation to

xByte

and

yByte

d. Else,

. Let

resultByte

be the result of applying the bitwise inclusive OR operation to

xByte

and

yByte

e. Set

+ 1.

f. Append

resultByte

to the end of

result

6. Return

result

The abstract operation ByteListEqual takes arguments

xBytes

of byte values) and

yBytes

of byte values).

It performs the following steps when called:

1. If

xBytes

and

yBytes

do not have the same number of elements, return

false

2. Let

be 0.

3. For each element

xByte

xBytes

, do

a. Let

yByte

yBytes

[

b. If

xByte

≠

yByte

, return

false

c. Set

+ 1.

4. Return

true

The following steps are taken:

1. Let

type

be the Element Type value in

be the value of the [[LittleEndian]] field of the

for

typedArray

.[[TypedArrayName]].

2. Let

isLittleEndian

3. Let

add

be a new

xBytes

yBytes

) that captures

type

and

isLittleEndian

and performs the following steps atomically when called:

a. Let

(

type

xBytes

isLittleEndian

b. Let

(

type

yBytes

isLittleEndian

c. Let

Type

(

d. Let

sum

::add(

e. Let

sumBytes

type

sum

isLittleEndian

sumBytes

xBytes

, and

yBytes

have the same number of elements.

g. Return

sumBytes

4. Return ?

(

typedArray

index

value

add

25.4.1.13 ByteListEqual (

xBytes

yBytes

)

25.4.2 Atomics.add (

typedArray

index

value

)

730

The following steps are taken:

1. Let

and

be a new

with parameters (

xBytes

yBytes

) that captures

nothing and performs the following steps atomically when called:

a. Return

ByteListBitwiseOp

(

xBytes

yBytes

(

typedArray

index

value

and

The following steps are taken:

1. Let

buffer

(

typedArray

2. Let

block

buffer

.[[ArrayBufferData]].

3. Let

indexedPosition

(

typedArray

index

4. Let

arrayTypeName

typedArray

.[[TypedArrayName]].

5. If

typedArray

.[[ContentType]] is

BigInt

, then

a. Let

expected

be ?

expectedValue

b. Let

replacement

replacementValue

6. Else,

a. Let

expected

expectedValue

)).

b. Let

replacement

(

replacementValue

)).

7. If

(

buffer

) is

true

, throw a

TypeError

exception.

8. NOTE: The above check is not redundant with the check in

because the call to

on the preceding lines can have arbitrary side effects, which could cause the

buffer to become detached.

9. Let

elementType

be the Element Type value in

be the Element Size value specified in

arrayTypeName

10. Let

elementSize

be the value of the [[LittleEndian]] field of the

for Element Type

elementType

11. Let

isLittleEndian

12. Let

expectedBytes

(

elementType

expected

isLittleEndian

13. Let

replacementBytes

(

elementType

replacement

isLittleEndian

14. If

IsSharedArrayBuffer

buffer

) is

true

, then

a. Let

execution

be the [[CandidateExecution]] field of the

b. Let

eventList

be the [[EventList]] field of the element in

execution

.[[EventsRecords]] whose

[[AgentSignifier]] is

().

c. Let

rawBytesRead

be a

e. NOTE: The comparison of the expected value and the read value is performed outside of the

of length

elementSize

whose elements are nondeterministically chosen byte

values.

d. NOTE: In implementations,

rawBytesRead

is the result of a load-link, of a load-exclusive, or of an

operand of a read-modify-write instruction on the underlying hardware. The nondeterminism is a
semantic prescription of the

memory model

to describe observable behaviour of hardware with weak

consistency.

read-

modify-write modification function

to avoid needlessly strong synchronization when the expected value

is not equal to the read value.

f. If

ByteListEqual

rawBytesRead

expectedBytes

) is

true

, then

i. Let

second

be a new

ReadModifyWriteSharedMemory

oldBytes

newBytes

)

that captures nothing and performs the following steps atomically when called:

1. Return

newBytes

25.4.3 Atomics.and (

typedArray

index

value

)

25.4.4 Atomics.compareExchange (

typedArray

index

expectedValue

replacementValue

)

731

ii. Let

event

{ [[Order]]:

SeqCst

, [[NoTear]]:

true

, [[Block]]:

block

, [[ByteIndex]]:

indexedPosition

, [[ElementSize]]:

elementSize

, [[Payload]]:

replacementBytes

[[ModifyOp]]:

second

g. Else,

i. Let

event

ReadSharedMemory

{ [[Order]]:

SeqCst

, [[NoTear]]:

true

, [[Block]]:

block

[[ByteIndex]]:

indexedPosition

, [[ElementSize]]:

elementSize

h. Append

event

eventList

i. Append

Chosen Value Record

{ [[Event]]:

event

, [[ChosenValue]]:

rawBytesRead

} to

execution

[[ChosenValues]].

15. Else,

a. Let

rawBytesRead

be a

of length

elementSize

whose elements are the sequence of

elementSize

bytes

starting with

block

[

indexedPosition

b. If

ByteListEqual

rawBytesRead

expectedBytes

) is

true

, then

i. Store the individual bytes of

replacementBytes

into

block

, starting at

block

[

indexedPosition

16. Return

elementType

rawBytesRead

isLittleEndian

The following steps are taken:

1. Let

second

be a new

oldBytes

newBytes

) that captures

nothing and performs the following steps atomically when called:

a. Return

newBytes

(

typedArray

index

value

second

The following steps are taken:

1. Let

size

2. Let

3. If

= 1, return

.[[IsLockFree1]].

4. If

= 2, return

.[[IsLockFree2]].

5. If

= 4, return

true

6. If

= 8, return

.[[IsLockFree8]].

7. Return

false

25.4.5 Atomics.exchange (

typedArray

index

value

)

25.4.6 Atomics.isLockFree (

size

)

732

NOTE

The following steps are taken:

1. Let

buffer

(

typedArray

2. Let

indexedPosition

(

typedArray

index

3. If

(

buffer

) is

true

, throw a

TypeError

exception.

4. NOTE: The above check is not redundant with the check in

because the call to

on the preceding line can have arbitrary side effects, which could cause the buffer to

become detached.

5. Let

arrayTypeName

typedArray

.[[TypedArrayName]].

6. Let

elementType

be the Element Type value in

arrayTypeName

7. Return

GetValueFromBuffer

buffer

indexedPosition

elementType

true

SeqCst

The following steps are taken:

1. Let

be a new

with parameters (

xBytes

yBytes

) that captures nothing

and performs the following steps atomically when called:

a. Return

ByteListBitwiseOp

(

xBytes

yBytes

(

typedArray

index

value

The following steps are taken:

1. Let

buffer

(

typedArray

2. Let

indexedPosition

(

typedArray

index

3. Let

arrayTypeName

typedArray

.[[TypedArrayName]].

4. If

arrayTypeName

"BigUint64Array"

"BigInt64Array"

, let

value

5. Otherwise, let

bytes will be performed without the calling

value

)).

Atomics.isLockFree

() is an optimization primitive. The intuition is that if the atomic step

of an atomic primitive (

compareExchange

load

store

add

sub

and

xor

, or

exchange

) on a datum of size

acquiring a

lock outside the

bytes comprising the datum, then

Atomics.isLockFree

(

) will return

true

. High-performance algorithms will use

Atomics.isLockFree

to determine whether to

use locks or atomic operations in critical sections. If an atomic primitive is not lock-free then it is
often more efficient for an algorithm to provide its own locking.

Atomics.isLockFree

(4) always returns

true

as that can be supported on all known

relevant hardware. Being able to assume this will generally simplify programs.

Regardless of the value of

Atomics.isLockFree

, all atomic operations are guaranteed to be

atomic. For example, they will never have a visible operation take place in the middle of the
operation (e.g., "tearing").

25.4.7 Atomics.load (

typedArray

index

)

25.4.8 Atomics.or (

typedArray

index

value

)

25.4.9 Atomics.store (

typedArray

index

value

)

733

6. If

(

buffer

) is

true

, throw a

TypeError

exception.

7. NOTE: The above check is not redundant with the check in

because the call to

on the preceding lines can have arbitrary side effects, which could cause the

buffer to become detached.

8. Let

elementType

be the Element Type value in

arrayTypeName

9. Perform

SetValueInBuffer

(

buffer

indexedPosition

elementType

true

SeqCst

10. Return

The following steps are taken:

1. Let

type

be the Element Type value in

be the value of the [[LittleEndian]] field of the

for

typedArray

.[[TypedArrayName]].

2. Let

isLittleEndian

3. Let

subtract

be a new

xBytes

yBytes

) that captures

type

and

isLittleEndian

and performs the following steps atomically when called:

a. Let

(

type

xBytes

isLittleEndian

b. Let

(

type

yBytes

isLittleEndian

c. Let

Type

(

d. Let

difference

::subtract(

e. Let

differenceBytes

type

difference

isLittleEndian

differenceBytes

xBytes

, and

yBytes

have the same number of elements.

g. Return

differenceBytes

4. Return ?

(

typedArray

index

value

subtract

Atomics.wait

puts the calling

in a wait queue and puts it to sleep until it is notified or the sleep times out.

The following steps are taken:

1. Let

buffer

(

typedArray

true

2. If

IsSharedArrayBuffer

buffer

) is

false

, throw a

TypeError

exception.

3. Let

indexedPosition

(

typedArray

index

4. Let

arrayTypeName

typedArray

.[[TypedArrayName]].

5. If

arrayTypeName

"BigInt64Array"

, let

ToBigInt64

value

6. Otherwise, let

ToInt32

value

7. Let

be ?

ToNumber

(

timeout

8. If

NaN

∞

𝔽

, let

be +

∞

; else if

∞

𝔽

, let

be 0; else let

max

(

), 0).

9. Let

AgentCanSuspend

().

10. If

false

, throw a

TypeError

exception.

11. Let

block

buffer

.[[ArrayBufferData]].

12. Let

GetWaiterList

block

indexedPosition

13. Perform

EnterCriticalSection

(

14. Let

elementType

be the Element Type value in

arrayTypeName

15. Let

be !

GetValueFromBuffer

(

buffer

indexedPosition

elementType

true

SeqCst

16. If

≠

, then

a. Perform

(

b. Return the String

"not-equal"

25.4.10 Atomics.sub (

typedArray

index

value

)

25.4.11 Atomics.wait (

typedArray

index

value

timeout

)

734

17. Let

().

18. Perform

AddWaiter

(

19. Let

notified

SuspendAgent

(

20. If

notified

true

, then

is not on the list of waiters in

21. Else,

a. Perform

RemoveWaiter

(

22. Perform

(

23. If

notified

true

, return the String

"ok"

24. Return the String

"timed-out"

Atomics.notify

notifies some agents that are sleeping in the wait queue. The following steps are taken:

1. Let

buffer

(

typedArray

true

2. Let

indexedPosition

(

typedArray

index

3. If

count

undefined

, let

be +

∞

4. Else,

a. Let

intCount

be ?

(

count

b. Let

max

intCount

, 0).

5. Let

block

buffer

.[[ArrayBufferData]].

6. Let

arrayTypeName

typedArray

.[[TypedArrayName]].

7. If

IsSharedArrayBuffer

buffer

) is

false

, return

𝔽

8. Let

GetWaiterList

block

indexedPosition

9. Let

be 0.

10. Perform

EnterCriticalSection

(

11. Let

12. Repeat, while

a. Let

b. Remove

from the front of

c. Perform

NotifyWaiter

d. Set

+ 1.

13. Perform

(

14. Return

The following steps are taken:

1. Let

xor

be a new

xBytes

yBytes

) that captures

nothing and performs the following steps atomically when called:

a. Return

ByteListBitwiseOp

(

xBytes

yBytes