mirror of
https://github.com/fluencelabs/assemblyscript
synced 2025-06-21 10:41:42 +00:00
Add atomic definitions (#524)
This commit is contained in:
Daniel Wirtz
GitHub
241
std/assembly/index.d.ts
vendored
241
std/assembly/index.d.ts
vendored
@ -163,6 +163,42 @@ declare function fmod(x: f64, y: f64): f64;
|
||||
/** Returns the 32-bit floating-point remainder of `x/y`. */
|
||||
declare function fmodf(x: f32, y: f32): f32;
|
||||
|
||||
/** Atomic operations. */
|
||||
declare namespace atomic {
|
||||
/** Atomically loads an integer value from memory and returns it. */
|
||||
export function load<T>(offset: usize, immOffset?: usize): T;
|
||||
/** Atomically stores an integer value to memory. */
|
||||
export function store<T>(offset: usize, value: T, immOffset?: usize): void;
|
||||
/** Atomically adds an integer value in memory. */
|
||||
export function add<T>(ptr: usize, value: T, immOffset?: usize): T;
|
||||
/** Atomically subtracts an integer value in memory. */
|
||||
export function sub<T>(ptr: usize, value: T, immOffset?: usize): T;
|
||||
/** Atomically performs a bitwise AND operation on an integer value in memory. */
|
||||
export function and<T>(ptr: usize, value: T, immOffset?: usize): T;
|
||||
/** Atomically performs a bitwise OR operation on an integer value in memory. */
|
||||
export function or<T>(ptr: usize, value: T, immOffset?: usize): T;
|
||||
/** Atomically performs a bitwise XOR operation on an integer value in memory. */
|
||||
export function xor<T>(ptr: usize, value: T, immOffset?: usize): T;
|
||||
/** Atomically exchanges an integer value in memory. */
|
||||
export function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;
|
||||
/** Atomically compares and exchanges an integer value in memory if the condition is met. */
|
||||
export function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;
|
||||
/** Performs a wait operation on an integer value in memory suspending this agent if the condition is met. */
|
||||
export function wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;
|
||||
/** Performs a notify operation on an integer value in memory waking up suspended agents. */
|
||||
export function notify<T>(ptr: usize, count: u32): i32;
|
||||
}
|
||||
|
||||
/** Describes the result of an atomic wait operation. */
|
||||
declare enum AtomicWaitResult {
|
||||
/** Woken by another agent. */
|
||||
OK,
|
||||
/** Loaded value did not match the expected value. */
|
||||
NOT_EQUAL,
|
||||
/** Not woken before the timeout expired. */
|
||||
TIMED_OUT
|
||||
}
|
||||
|
||||
/** Converts any other numeric value to an 8-bit signed integer. */
|
||||
declare function i8(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8;
|
||||
declare namespace i8 {
|
||||
@ -186,22 +222,92 @@ declare namespace i32 {
|
||||
export const MIN_VALUE: i32;
|
||||
/** Largest representable value. */
|
||||
export const MAX_VALUE: i32;
|
||||
/** Loads an 8-bit signed integer from memory and returns it as a 32-bit integer. */
|
||||
/** Loads an 8-bit signed integer value from memory and returns it as a 32-bit integer. */
|
||||
export function load8_s(offset: usize, immOffset?: usize, immAlign?: usize): i32;
|
||||
/** Loads an 8-bit unsigned integer from memory and returns it as a 32-bit integer. */
|
||||
/** Loads an 8-bit unsigned integer value from memory and returns it as a 32-bit integer. */
|
||||
export function load8_u(offset: usize, immOffset?: usize, immAlign?: usize): i32;
|
||||
/** Loads a 16-bit signed integer from memory and returns it as a 32-bit integer. */
|
||||
/** Loads a 16-bit signed integer value from memory and returns it as a 32-bit integer. */
|
||||
export function load16_s(offset: usize, immOffset?: usize, immAlign?: usize): i32;
|
||||
/** Loads a 16-bit unsigned integer from memory and returns it as a 32-bit integer. */
|
||||
/** Loads a 16-bit unsigned integer value from memory and returns it as a 32-bit integer. */
|
||||
export function load16_u(offset: usize, immOffset?: usize, immAlign?: usize): i32;
|
||||
/** Loads a 32-bit integer from memory. */
|
||||
/** Loads a 32-bit integer value from memory. */
|
||||
export function load(offset: usize, immOffset?: usize, immAlign?: usize): i32;
|
||||
/** Stores a 32-bit integer to memory as an 8-bit integer. */
|
||||
/** Stores a 32-bit integer value to memory as an 8-bit integer. */
|
||||
export function store8(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
|
||||
/** Stores a 32-bit integer to memory as a 16-bit integer. */
|
||||
/** Stores a 32-bit integer value to memory as a 16-bit integer. */
|
||||
export function store16(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
|
||||
/** Stores a 32-bit integer to memory. */
|
||||
/** Stores a 32-bit integer value to memory. */
|
||||
export function store(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
|
||||
/** Atomic 32-bit integer operations. */
|
||||
export namespace atomic {
|
||||
/** Atomically loads an 8-bit unsigned integer value from memory and returns it as a 32-bit integer. */
|
||||
export function load8_u(offset: usize, immOffset?: usize): i32;
|
||||
/** Atomically loads a 16-bit unsigned integer value from memory and returns it as a 32-bit integer. */
|
||||
export function load16_u(offset: usize, immOffset?: usize): i32;
|
||||
/** Atomically loads a 32-bit integer value from memory and returns it. */
|
||||
export function load(offset: usize, immOffset?: usize): i32;
|
||||
/** Atomically stores a 32-bit integer value to memory as an 8-bit integer. */
|
||||
export function store8(offset: usize, value: i32, immOffset?: usize): void;
|
||||
/** Atomically stores a 32-bit integer value to memory as a 16-bit integer. */
|
||||
export function store16(offset: usize, value: i32, immOffset?: usize): void;
|
||||
/** Atomically stores a 32-bit integer value to memory. */
|
||||
export function store(offset: usize, value: i32, immOffset?: usize): void;
|
||||
/** Performs a wait operation on a 32-bit integer value in memory suspending this agent if the condition is met. */
|
||||
export function wait(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;
|
||||
/** Performs a notify operation on a 32-bit integer value in memory waking up suspended agents. */
|
||||
export function notify(ptr: usize, count: i32): i32;
|
||||
/** Atomic 32-bit integer read-modify-write operations on 8-bit values. */
|
||||
export namespace rmw8 {
|
||||
/** Atomically adds an 8-bit unsigned integer value in memory. */
|
||||
export function add_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically subtracts an 8-bit unsigned integer value in memory. */
|
||||
export function sub_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise AND operation an 8-bit unsigned integer value in memory. */
|
||||
export function and_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise OR operation an 8-bit unsigned integer value in memory. */
|
||||
export function or_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise XOR operation an 8-bit unsigned integer value in memory. */
|
||||
export function xor_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically exchanges an 8-bit unsigned integer value in memory. */
|
||||
export function xchg_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically compares and exchanges an 8-bit unsigned integer value in memory if the condition is met. */
|
||||
export function cmpxchg_u(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
|
||||
}
|
||||
/** Atomic 32-bit integer read-modify-write operations on 16-bit values. */
|
||||
export namespace rmw16 {
|
||||
/** Atomically adds a 16-bit unsigned integer value in memory. */
|
||||
export function add_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically adds a 16-bit unsigned integer value in memory. */
|
||||
export function sub_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise AND operation a 16-bit unsigned integer value in memory. */
|
||||
export function and_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise OR operation a 16-bit unsigned integer value in memory. */
|
||||
export function or_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise XOR operation a 16-bit unsigned integer value in memory. */
|
||||
export function xor_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically exchanges a 16-bit unsigned integer value in memory. */
|
||||
export function xchg_u(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically compares and exchanges a 16-bit unsigned integer value in memory if the condition is met. */
|
||||
export function cmpxchg_u(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
|
||||
}
|
||||
/** Atomic 32-bit integer read-modify-write operations. */
|
||||
export namespace rmw {
|
||||
/** Atomically adds a 32-bit integer value in memory. */
|
||||
export function add(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically subtracts a 32-bit integer value in memory. */
|
||||
export function sub(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise AND operation a 32-bit integer value in memory. */
|
||||
export function and(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise OR operation a 32-bit integer value in memory. */
|
||||
export function or(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically performs a bitwise XOR operation a 32-bit integer value in memory. */
|
||||
export function xor(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically exchanges a 32-bit integer value in memory. */
|
||||
export function xchg(offset: usize, value: i32, immOffset?: usize): i32;
|
||||
/** Atomically compares and exchanges a 32-bit integer value in memory if the condition is met. */
|
||||
export function cmpxchg(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Converts any other numeric value to a 64-bit signed integer. */
|
||||
declare function i64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i64;
|
||||
@ -210,28 +316,119 @@ declare namespace i64 {
|
||||
export const MIN_VALUE: i64;
|
||||
/** Largest representable value. */
|
||||
export const MAX_VALUE: i64;
|
||||
/** Loads an 8-bit signed integer from memory and returns it as a 64-bit signed integer. */
|
||||
/** Loads an 8-bit signed integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load8_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
|
||||
/** Loads an 8-bit unsigned integer from memory and returns it as a 64-bit unsigned integer. */
|
||||
export function load8_u(offset: usize, immOffset?: usize, immAlign?: usize): u64;
|
||||
/** Loads a 16-bit signed integer from memory and returns it as a 64-bit signed integer. */
|
||||
/** Loads an 8-bit unsigned integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load8_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
|
||||
/** Loads a 16-bit signed integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load16_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
|
||||
/** Loads a 16-bit unsigned integer from memory and returns it as a 64-bit unsigned integer. */
|
||||
export function load16_u(offset: usize, immOffset?: usize, immAlign?: usize): u64;
|
||||
/** Loads a 32-bit signed integer from memory and returns it as a 64-bit signed integer. */
|
||||
/** Loads a 16-bit unsigned integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load16_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
|
||||
/** Loads a 32-bit signed integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load32_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
|
||||
/** Loads a 32-bit unsigned integer from memory and returns it as a 64-bit unsigned integer. */
|
||||
export function load32_u(offset: usize, immOffset?: usize, immAlign?: usize): u64;
|
||||
/** Loads a 64-bit unsigned integer from memory. */
|
||||
/** Loads a 32-bit unsigned integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load32_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
|
||||
/** Loads a 64-bit unsigned integer value from memory. */
|
||||
export function load(offset: usize, immOffset?: usize, immAlign?: usize): i64;
|
||||
/** Stores a 64-bit integer to memory as an 8-bit integer. */
|
||||
/** Stores a 64-bit integer value to memory as an 8-bit integer. */
|
||||
export function store8(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
|
||||
/** Stores a 64-bit integer to memory as a 16-bit integer. */
|
||||
/** Stores a 64-bit integer value to memory as a 16-bit integer. */
|
||||
export function store16(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
|
||||
/** Stores a 64-bit integer to memory as a 32-bit integer. */
|
||||
/** Stores a 64-bit integer value to memory as a 32-bit integer. */
|
||||
export function store32(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
|
||||
/** Stores a 64-bit integer to memory. */
|
||||
/** Stores a 64-bit integer value to memory. */
|
||||
export function store(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
|
||||
/** Atomic 64-bit integer operations. */
|
||||
export namespace atomic {
|
||||
/** Atomically loads an 8-bit unsigned integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load8_u(offset: usize, immOffset?: usize): i64;
|
||||
/** Atomically loads a 16-bit unsigned integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load16_u(offset: usize, immOffset?: usize): i64;
|
||||
/** Atomically loads a 32-bit unsigned integer value from memory and returns it as a 64-bit integer. */
|
||||
export function load32_u(offset: usize, immOffset?: usize): i64;
|
||||
/** Atomically loads a 64-bit integer value from memory and returns it. */
|
||||
export function load(offset: usize, immOffset?: usize): i64;
|
||||
/** Atomically stores a 64-bit integer value to memory as an 8-bit integer. */
|
||||
export function store8(offset: usize, value: i64, immOffset?: usize): void;
|
||||
/** Atomically stores a 64-bit integer value to memory as a 16-bit integer. */
|
||||
export function store16(offset: usize, value: i64, immOffset?: usize): void;
|
||||
/** Atomically stores a 64-bit integer value to memory as a 32-bit integer. */
|
||||
export function store32(offset: usize, value: i64, immOffset?: usize): void;
|
||||
/** Atomically stores a 64-bit integer value to memory. */
|
||||
export function store(offset: usize, value: i64, immOffset?: usize): void;
|
||||
/** Performs a wait operation on a 64-bit integer value in memory suspending this agent if the condition is met. */
|
||||
export function wait(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;
|
||||
/** Performs a notify operation on a 64-bit integer value in memory waking up suspended agents. */
|
||||
export function notify(ptr: usize, count: i32): i32;
|
||||
/** Atomic 64-bit integer read-modify-write operations on 8-bit values. */
|
||||
export namespace rmw8 {
|
||||
/** Atomically adds an 8-bit unsigned integer value in memory. */
|
||||
export function add_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically subtracts an 8-bit unsigned integer value in memory. */
|
||||
export function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise AND operation on an 8-bit unsigned integer value in memory. */
|
||||
export function and_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise OR operation on an 8-bit unsigned integer value in memory. */
|
||||
export function or_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise XOR operation on an 8-bit unsigned integer value in memory. */
|
||||
export function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically exchanges an 8-bit unsigned integer value in memory. */
|
||||
export function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically compares and exchanges an 8-bit unsigned integer value in memory if the condition is met. */
|
||||
export function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
|
||||
}
|
||||
/** Atomic 64-bit integer read-modify-write operations on 16-bit values. */
|
||||
export namespace rmw16 {
|
||||
/** Atomically adds a 16-bit unsigned integer value in memory. */
|
||||
export function add_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically subtracts a 16-bit unsigned integer value in memory. */
|
||||
export function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise AND operation on a 16-bit unsigned integer value in memory. */
|
||||
export function and_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise OR operation on a 16-bit unsigned integer value in memory. */
|
||||
export function or_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise XOR operation on a 16-bit unsigned integer value in memory. */
|
||||
export function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically exchanges a 16-bit unsigned integer value in memory. */
|
||||
export function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically compares and exchanges a 16-bit unsigned integer value in memory if the condition is met. */
|
||||
export function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
|
||||
}
|
||||
/** Atomic 64-bit integer read-modify-write operations on 32-bit values. */
|
||||
export namespace rmw32 {
|
||||
/** Atomically adds a 32-bit unsigned integer value in memory. */
|
||||
export function add_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically subtracts a 32-bit unsigned integer value in memory. */
|
||||
export function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise AND operation on a 32-bit unsigned integer value in memory. */
|
||||
export function and_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise OR operation on a 32-bit unsigned integer value in memory. */
|
||||
export function or_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise XOR operation on a 32-bit unsigned integer value in memory. */
|
||||
export function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically exchanges a 32-bit unsigned integer value in memory. */
|
||||
export function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically compares and exchanges a 32-bit unsigned integer value in memory if the condition is met. */
|
||||
export function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
|
||||
}
|
||||
/** Atomic 64-bit integer read-modify-write operations. */
|
||||
export namespace rmw {
|
||||
/** Atomically adds a 64-bit integer value in memory. */
|
||||
export function add(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically subtracts a 64-bit integer value in memory. */
|
||||
export function sub(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise AND operation on a 64-bit integer value in memory. */
|
||||
export function and(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise OR operation on a 64-bit integer value in memory. */
|
||||
export function or(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically performs a bitwise XOR operation on a 64-bit integer value in memory. */
|
||||
export function xor(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically exchanges a 64-bit integer value in memory. */
|
||||
export function xchg(offset: usize, value: i64, immOffset?: usize): i64;
|
||||
/** Atomically compares and exchanges a 64-bit integer value in memory if the condition is met. */
|
||||
export function cmpxchg(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Converts any other numeric value to a 32-bit (in WASM32) respectivel 64-bit (in WASM64) signed integer. */
|
||||
declare var isize: typeof i32 | typeof i64;
|
||||
|
||||
Reference in New Issue
Block a user