diff --git a/quest/m2/ts-shared.md b/quest/m2/ts-shared.md index 2081981c1..e2b0470fc 100644 --- a/quest/m2/ts-shared.md +++ b/quest/m2/ts-shared.md @@ -17,18 +17,20 @@ Decided with the maintainer on 2026-10-23: deterministic reference counts in The async spike ([#16](https://github.com/kixelated/rust2/pull/16)) landed what its kio-shaped fixture needs, in `rt/task.ts`: `rt.Arc` counts strong references and drops its value with the last, `rt.Weak` upgrades while one is left, and `rt.Mutex` -is its own guard. Left: `Rc`, `weak_count` (a dropped `Weak` counts nothing yet), -`RwLock`, atomics, `OnceLock`, `Cell`, and `RefCell`. +is its own guard. `rt.Atomic` holds a `bool` or an integer, and its operations check +their orderings as std does. Left: `Rc`, `weak_count` (a dropped `Weak` counts nothing +yet), `RwLock`, `OnceLock`, `Cell`, and `RefCell`. - `Send` and `Sync` bounds have no meaning in JS; accept them. - Keep Rust's failure modes where they are defined: a `RefCell` double borrow panics. A re-entrant `Mutex` lock on one thread is unspecified in Rust; pick a loud failure (panic) and document it. - The census of moq-net's [model](/quest/m2/ts-model/README.md) on 2026-10-27 adds: - atomics as `Atomic` with `Ordering` arguments (about 345 refusals, 125 in - `stats.rs`), `PoisonError::into_inner` with a lock poisoned by a panic while held, - `thread_local!` (`LocalKey::with`), `thread::panicking`, and `Mutex::get_mut`. Atomics - are 139 of kio's 172 refusals here. + `PoisonError::into_inner` with a lock poisoned by a panic while held, + `thread_local!` (`LocalKey::with`), `thread::panicking`, and `Mutex::get_mut`. +- A `static` atomic (`static NEXT: AtomicU64`, 2 in moq-net and 1 in kio) is still + refused as a constant of type `&Atomic`: a `static` with interior mutability needs one + module-level value that every use shares. - Measure the counter overhead on the [TS benchmark](/ts/README.md#bench). Public API: the translator's output for shared and interior-mutable types. diff --git a/ts/README.md b/ts/README.md index 943ada3dc..cedda1358 100644 --- a/ts/README.md +++ b/ts/README.md @@ -60,7 +60,7 @@ and each type a module of its own beside it, holding the type and its functions (`coding/decode.Decoder.ts`), each with a `.ts.map` source map into the Rust it came from. `rt.ts` beside them is the runtime: what std does that JS does not, with iterators in `rt/iter.ts`, `str`'s searches -in `rt/str.ts`, collections in `rt/collections.ts`, ownership and async in +in `rt/str.ts`, collections in `rt/collections.ts`, ownership, atomics, and async in `rt/task.ts`, `f64`'s methods in `rt/float.ts`, and `Duration` in `rt/time.ts`. What translates from std's own MIR, `Option`'s, `Result`'s, and `Poll`'s methods, goes in a module under its crate's name, as `core/option.ts` holds `map$Option_u64_u64_rescale_closure0`. @@ -91,6 +91,7 @@ in `rt/str.ts`, collections in `rt/collections.ts`, ownership and async in | a type that drops | a class with `[Symbol.dispose]`: its `Drop` impl, then its fields | | a type's function | a function of the type's module, taking `self` first: `Decoder.slice(dec, 4)` after `import * as Decoder` | | `Arc`, `Weak`, `Mutex` | `rt.Arc`, counted; `rt.Weak`; `rt.Mutex`, its own guard | +| `AtomicU32` and the others of `bool` and integers | `rt.Atomic`, the `rt.Place` of its value; an `atomic::Ordering` is its discriminant, and one an operation can't take panics as std's does | | `async fn` | a function returning `rt.Future`: a class of its own, its coroutine's state machine | | `Poll`, `Waker`, `Context` | `T \| typeof rt.Pending`, refused if `T` can already be pending; `rt.Waker`, which is also the context | | `pin!(x)`, `poll_fn(f)`, `future::pending()` | `x`; `rt.PollFn`, which drops `f` with itself; `rt.NEVER` | diff --git a/ts/fixtures/lang/expected/atomics.Stats.ts b/ts/fixtures/lang/expected/atomics.Stats.ts new file mode 100644 index 000000000..e533ac0fe --- /dev/null +++ b/ts/fixtures/lang/expected/atomics.Stats.ts @@ -0,0 +1,16 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function default$Default(): Stats { + return { sent: new rt.Atomic(0), open: new rt.Atomic(false), peers: new rt.Atomic(0) }; +} + +/** Counters shared by `Arc`, in fields, as moq-net's stats are. */ +export interface Stats { + sent: rt.Atomic; + open: rt.Atomic; + peers: rt.Atomic; +} + +//# sourceMappingURL=atomics.Stats.ts.map diff --git a/ts/fixtures/lang/expected/atomics.ts b/ts/fixtures/lang/expected/atomics.ts new file mode 100644 index 000000000..bd94dc5a0 --- /dev/null +++ b/ts/fixtures/lang/expected/atomics.ts @@ -0,0 +1,1294 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import * as Stats from "./atomics.Stats.ts"; +import { isSomeAnd$Option_u8_bools_closure0 } from "./core/option.ts"; +import { unwrapOr$Result_i16_i16, unwrapOr$Result_i32_i32, unwrapOr$Result_i64_i64, unwrapOr$Result_i8_i8, unwrapOr$Result_isize_isize, unwrapOr$Result_u16_u16, unwrapOr$Result_u32_u32, unwrapOr$Result_u64_u64, unwrapOr$Result_u8_u8, unwrapOr$Result_usize_usize } from "./core/result.ts"; + +/** An ordering from `b`: one of `valid`, or from 0xf0 on any, which may panic. */ +export function order(b: rt.u8, valid: rt.AtomicOrdering[]): rt.AtomicOrdering { + if (!(b >= 240)) { + const _12: rt.usize = rt.usizeRem(b as rt.usize, valid.length); + rt.idx(valid, _12); + return valid[_12]; + } + const _5: rt.usize = rt.usizeRem(b as rt.usize, [0, 1, 2, 3, 4].length); + if (!(_5 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _5); + } + return [0, 1, 2, 3, 4][_5]; +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.i16; + let current!: rt.i16; + let result!: rt.Result; + let x!: rt.i16; + const buf: Uint8Array = rt.bytes(2); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.i16 = rt.i16FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.i16 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(2); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.i16 = rt.i16FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.i16 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.i16WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.i16WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.i16WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i16): rt.i16 | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i16CheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.i16WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i16): rt.i16 => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i16WrappingSub(x5, v) ^ 1; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_i16_i16(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i16): rt.i16 | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = _116.v ^ v; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.i32; + let current!: rt.i32; + let result!: rt.Result; + let x!: rt.i32; + const buf: Uint8Array = rt.bytes(4); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.i32 = rt.i32FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.i32 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(4); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.i32 = rt.i32FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.i32 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.i32WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.i32WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.i32WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i32): rt.i32 | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i32CheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.i32WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i32): rt.i32 => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i32WrappingSub(x5, v) ^ 1; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_i32_i32(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i32): rt.i32 | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = _116.v ^ v; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.i64; + let current!: rt.i64; + let result!: rt.Result; + let x!: rt.i64; + const buf: Uint8Array = rt.bytes(8); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.i64 = rt.i64FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.i64 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(8); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.i64 = rt.i64FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.i64 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.i64WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.i64WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => rt.i64And(old, value), v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => rt.i64Or(old, value), v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => rt.i64Xor(old, value), v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.i64Max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.i64Min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.i64WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.i64Eq); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.i64Eq); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i64): rt.i64 | undefined => { + rt.byteVecPush(out, 192); + if (rt.i64Ne(x6, v)) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i64CheckedAdd(x6, v); + }, rt.i64Eq); + if (_98.ok) { + old = _98.value; + } else { + old = rt.i64WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i64): rt.i64 => { + rt.byteVecPush(out, 193); + if (rt.i64Ne(x5, v)) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i64Xor(rt.i64WrappingSub(x5, v), 1); + }, rt.i64Eq); + } else if (_60 === 14) { + old = unwrapOr$Result_i64_i64(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i64): rt.i64 | undefined => { + return rt.thenSome(rt.i64Ne(x4, v), v); + }, rt.i64Eq), v); + } else { + const _116: rt.Place = atomic; + _116.v = rt.i64Xor(_116.v, v); + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.i8; + let current!: rt.i8; + let result!: rt.Result; + let x!: rt.i8; + const buf: Uint8Array = Uint8Array.of(0); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.i8 = rt.i8FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.i8 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = Uint8Array.of(0); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.i8 = rt.i8FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.i8 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.i8WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.i8WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.i8WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i8): rt.i8 | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i8CheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.i8WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i8): rt.i8 => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.i8WrappingSub(x5, v) ^ 1; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_i8_i8(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i8): rt.i8 | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = _116.v ^ v; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.isize; + let current!: rt.isize; + let result!: rt.Result; + let x!: rt.isize; + const buf: Uint8Array = rt.bytes(4); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.isize = rt.isizeFromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.isize = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(4); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.isize = rt.isizeFromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.isize = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.isizeWrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.isizeWrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.isizeWrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.isize): rt.isize | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.isizeCheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.isizeWrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.isize): rt.isize => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.isizeWrappingSub(x5, v) ^ 1; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_isize_isize(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.isize): rt.isize | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = _116.v ^ v; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.u16; + let current!: rt.u16; + let result!: rt.Result; + let x!: rt.u16; + const buf: Uint8Array = rt.bytes(2); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.u16 = rt.u16FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.u16 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(2); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.u16 = rt.u16FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.u16 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.u16WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.u16WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.u16WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u16): rt.u16 | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.u16CheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.u16WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u16): rt.u16 => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.u16WrappingSub(x5, v) ^ 1; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_u16_u16(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u16): rt.u16 | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = _116.v ^ v; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.u32; + let current!: rt.u32; + let result!: rt.Result; + let x!: rt.u32; + const buf: Uint8Array = rt.bytes(4); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.u32 = rt.u32FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.u32 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(4); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.u32 = rt.u32FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.u32 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.u32WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.u32WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => (old & value) >>> 0, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => (old | value) >>> 0, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => (old ^ value) >>> 0, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.u32WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u32): rt.u32 | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.u32CheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.u32WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u32): rt.u32 => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return (rt.u32WrappingSub(x5, v) ^ 1) >>> 0; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_u32_u32(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u32): rt.u32 | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = (_116.v ^ v) >>> 0; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.u64; + let current!: rt.u64; + let result!: rt.Result; + let x!: rt.u64; + const buf: Uint8Array = rt.bytes(8); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.u64 = rt.u64FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.u64 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(8); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.u64 = rt.u64FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.u64 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.u64WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.u64WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => rt.u64And(old, value), v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => rt.u64Or(old, value), v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => rt.u64Xor(old, value), v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.u64Max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.u64Min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.u64WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.u64Eq); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.u64Eq); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u64): rt.u64 | undefined => { + rt.byteVecPush(out, 192); + if (rt.u64Ne(x6, v)) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.u64CheckedAdd(x6, v); + }, rt.u64Eq); + if (_98.ok) { + old = _98.value; + } else { + old = rt.u64WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u64): rt.u64 => { + rt.byteVecPush(out, 193); + if (rt.u64Ne(x5, v)) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.u64Xor(rt.u64WrappingSub(x5, v), 1); + }, rt.u64Eq); + } else if (_60 === 14) { + old = unwrapOr$Result_u64_u64(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u64): rt.u64 | undefined => { + return rt.thenSome(rt.u64Ne(x4, v), v); + }, rt.u64Eq), v); + } else { + const _116: rt.Place = atomic; + _116.v = rt.u64Xor(_116.v, v); + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.u8; + let current!: rt.u8; + let result!: rt.Result; + let x!: rt.u8; + const buf: Uint8Array = Uint8Array.of(0); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.u8 = rt.u8FromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.u8 = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = Uint8Array.of(0); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.u8 = rt.u8FromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.u8 = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.u8WrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.u8WrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.u8WrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u8): rt.u8 | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.u8CheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.u8WrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u8): rt.u8 => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.u8WrappingSub(x5, v) ^ 1; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_u8_u8(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u8): rt.u8 | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = _116.v ^ v; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(atomic.v))); +} + +/** + * Steps of an operation, an ordering, and an operand on one atomic, each putting + * what it read. + */ +export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: rt.usize; + let current!: rt.usize; + let result!: rt.Result; + let x!: rt.usize; + const buf: Uint8Array = rt.bytes(4); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); + const _18: rt.usize = rt.usizeFromBeBytes(buf); + const _20: rt.ByteSlice = rt.byteSliceRange(data, n); + const first: rt.usize = _18; + let data2: rt.ByteSlice = _20; + const atomic: rt.Atomic = new rt.Atomic(first); + while (data2.length >= 2) { + const op: rt.u8 = data2.data[data2.start]; + const b: rt.u8 = data2.data[data2.start + 1]; + const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const buf2: Uint8Array = rt.bytes(4); + const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); + const _43: rt.usize = rt.usizeFromBeBytes(buf2); + const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); + const v: rt.usize = _43; + data2 = _45; + const b2: rt.u8 = b; + const op2: rt.u8 = op; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rt.u8 = rt.u8Rem(op2, 16); + if (_60 === 0) { + const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(atomic, _63); + } else if (_60 === 1) { + const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(atomic, v, _68); + old = v; + } else if (_60 === 2) { + old = rt.atomicSwap(atomic, v, any); + } else if (_60 === 3) { + old = rt.atomicFetch(atomic, rt.usizeWrappingAdd, v, any); + } else if (_60 === 4) { + old = rt.atomicFetch(atomic, rt.usizeWrappingSub, v, any); + } else if (_60 === 5) { + old = rt.atomicFetch(atomic, (old, value) => (old & value) >>> 0, v, any); + } else if (_60 === 6) { + old = rt.atomicFetch(atomic, (old, value) => (old | value) >>> 0, v, any); + } else if (_60 === 7) { + old = rt.atomicFetch(atomic, (old, value) => (old ^ value) >>> 0, v, any); + } else if (_60 === 8) { + old = rt.atomicFetch(atomic, rt.max, v, any); + } else if (_60 === 9) { + old = rt.atomicFetch(atomic, rt.min, v, any); + } else if (_60 === 10 || _60 === 11) { + if (!((b2 & 1) === 0)) { + current = rt.usizeWrappingAdd(v, 1); + } else { + current = rt.atomicLoad(atomic, 0); + } + if (!(rt.u8Rem(op2, 16) === 10)) { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } else { + result = rt.atomicCompareExchange(atomic, current, v, any, failure); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + x = result.value; + } else { + x = result.error; + } + old = x; + } else if (_60 === 12) { + const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.usize): rt.usize | undefined => { + rt.byteVecPush(out, 192); + if (x6 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return rt.usizeCheckedAdd(x6, v); + }); + if (_98.ok) { + old = _98.value; + } else { + old = rt.usizeWrappingAdd(_98.error, 1); + } + } else if (_60 === 13) { + old = rt.atomicUpdate(atomic, any, failure, (x5: rt.usize): rt.usize => { + rt.byteVecPush(out, 193); + if (x5 !== v) { + if ((b2 & 2) === 0) { + rt.atomicStore(atomic, v, 0); + } + } + return (rt.usizeWrappingSub(x5, v) ^ 1) >>> 0; + }); + } else if (_60 === 14) { + old = unwrapOr$Result_usize_usize(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.usize): rt.usize | undefined => { + return rt.thenSome(x4 !== v, v); + }), v); + } else { + const _116: rt.Place = atomic; + _116.v = (_116.v ^ v) >>> 0; + old = rt.atomicLoad(atomic, 4); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(old))); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(atomic.v))); +} + +export function bools(data: rt.ByteSlice, out: rt.ByteVec): void { + let old!: boolean; + const flag: rt.Atomic = new rt.Atomic(isSomeAnd$Option_u8_bools_closure0(rt.byteSliceFirst(data), (_2: rt.u8): boolean => { + return (_2 & 1) === 1; + })); + let dataData: Uint8Array = data.data; + let dataStart: number = data.start; + let dataLen: number = data.length; + while (dataLen >= 2) { + const op: rt.u8 = dataData[dataStart]; + const b: rt.u8 = dataData[dataStart + 1]; + const restData: Uint8Array = dataData; + const restStart: number = dataStart + 2; + const restLen: number = dataLen - 2; + dataData = restData; + dataStart = restStart; + dataLen = restLen; + const op2: rt.u8 = op; + const b2: rt.u8 = b; + const v: boolean = (b2 & 1) === 1; + const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const _23: rt.u8 = rt.u8Rem(op2, 11); + if (_23 === 0) { + const _26: rt.AtomicOrdering = order(b2, [0, 2, 4]); + old = rt.atomicLoad(flag, _26); + } else if (_23 === 1) { + const _31: rt.AtomicOrdering = order(b2, [0, 1, 4]); + rt.atomicStore(flag, v, _31); + old = v; + } else if (_23 === 2) { + old = rt.atomicSwap(flag, v, any); + } else if (_23 === 3) { + old = rt.atomicFetch(flag, (old, value) => old && value, v, any); + } else if (_23 === 4) { + old = rt.atomicFetch(flag, (old, value) => old || value, v, any); + } else if (_23 === 5) { + old = rt.atomicFetch(flag, (old, value) => old !== value, v, any); + } else if (_23 === 6) { + old = rt.atomicFetch(flag, (old, value) => !(old && value), v, any); + } else if (_23 === 7) { + old = rt.atomicFetch(flag, (old, value) => old !== value, true, any); + } else if (_23 === 8) { + const _42: boolean = !v; + const _43: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _40: rt.Result = rt.atomicCompareExchange(flag, v, _42, any, _43); + if (_40.ok) { + old = _40.value; + } else { + old = !_40.error; + } + } else if (_23 === 9) { + rt.fence(order(b2, [1, 2, 3, 4])); + rt.fence(order(b2 ^ 15, [1, 2, 3, 4])); + old = v; + } else { + old = rt.atomicUpdate(flag, any, 0, (x3: boolean): boolean => { + rt.byteVecPush(out, 193); + if (x3 !== v) { + rt.atomicStore(flag, v, 0); + } + return x3 !== v; + }); + } + rt.byteVecPush(out, old ? 1 : 0); + } + rt.byteVecPush(out, flag.v ? 1 : 0); +} + +/** A load at an ordering passed in, as moq-net's frame does. */ +export function sent(stats: Stats.Stats, ord: rt.AtomicOrdering): rt.u64 { + return rt.atomicLoad(stats.sent, ord); +} + +export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { + let stats!: rt.Arc; + let peer!: rt.Arc; + let stats2!: rt.Arc; + let unwind: number = 0; + try { + stats = new rt.Arc(Stats.default$Default()); + unwind = 39; + peer = rt.arcClone(stats); + unwind = 38; + for (const b of rt.byteSliceView(data)) { + if (!((b & 1) === 0)) { + stats2 = peer; + } else { + stats2 = stats; + } + rt.atomicFetch(stats2.value.sent, rt.u64WrappingAdd, rt.u64Shl(b as rt.u64, 50), 0); + rt.atomicFetch(stats2.value.peers, rt.usizeWrappingSub, (b & 2) === 0 ? 1 : 0, 1); + rt.atomicStore(stats2.value.open, b > 128, 1); + rt.byteVecPush(out, rt.atomicLoad(stats2.value.open, 2) ? 1 : 0); + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(sent(peer.value, order(data.length & 0xff, [0, 2, 4]))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.atomicLoad(peer.value.peers, 4)))); + rt.byteVecPush(out, stats.strong & 0xff); + unwind = 39; + rt.drop(peer); + unwind = 0; + rt.drop(stats); + } catch (e) { + if (unwind === 0) { + throw e; + } + if (unwind === 38) { + rt.drop(peer); + } + rt.drop(stats); + throw e; + } +} + +export function atomics(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _4: rt.u8 = rt.u8Rem(kind, 12); + if (_4 === 0) { + u8s(data, out); + } else if (_4 === 1) { + u16s(data, out); + } else if (_4 === 2) { + u32s(data, out); + } else if (_4 === 3) { + u64s(data, out); + } else if (_4 === 4) { + usizes(data, out); + } else if (_4 === 5) { + i8s(data, out); + } else if (_4 === 6) { + i16s(data, out); + } else if (_4 === 7) { + i32s(data, out); + } else if (_4 === 8) { + i64s(data, out); + } else if (_4 === 9) { + isizes(data, out); + } else if (_4 === 10) { + bools(data, out); + } else { + shared(data, out); + } +} + +//# sourceMappingURL=atomics.ts.map diff --git a/ts/fixtures/lang/expected/combinators.ts b/ts/fixtures/lang/expected/combinators.ts index cda96580a..734bbc2e5 100644 --- a/ts/fixtures/lang/expected/combinators.ts +++ b/ts/fixtures/lang/expected/combinators.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; import { copy$Result_u32s_u16, copy$u32s } from "./lib.ts"; -import { isSomeAnd$Option_u8_options_closure0, isNoneOr$Option_u8_options_closure1, unwrapOr$Option_u8, unwrapOrElse$Option_String_owned_closure3, unwrapOrElse$Option_u8_options_closure9, unwrapOrDefault$Option_String, unwrapOrDefault$Option_Vec_u8, unwrapOrDefault$Option_u8, map$Option_u8_String_owned_closure0, map$Option_u8_Vec_u8_owned_closure4, map$Option_u8_u32s_owned_closure9, map$Option_u8_u8_made_closure0_closure0, inspect$Option_u8_options_closure11, mapOr$Option_u16_u8_hash_maps_closure0, mapOr$Option_u8_u8_iters_closure3, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOrElse$Option_u8_u8_options_closure7_options_closure8, okOr$Option_u32s_u8, okOr$Option_u8_u16, okOr$Option_u8_u8, okOrElse$Option_Vec_u8_String_owned_closure5, okOrElse$Option_u8_u16_options_closure12, and$Option_u8_u8, andThen$Option_u8_u8_options_closure2, filter$Option_String_owned_closure1, filter$Option_u8_combinators_closure0, or$Option_u8, orElse$Option_String_owned_closure2, orElse$Option_u8_options_closure6, xor$Option_u8, zip$Option_u8_u8, clone$Clone_Option_String } from "./core/option.ts"; +import { isSomeAnd$Option_u8_bools_closure0, isNoneOr$Option_u8_options_closure1, unwrapOr$Option_u8, unwrapOrElse$Option_String_owned_closure3, unwrapOrElse$Option_u8_options_closure9, unwrapOrDefault$Option_String, unwrapOrDefault$Option_Vec_u8, unwrapOrDefault$Option_u8, map$Option_u8_String_owned_closure0, map$Option_u8_Vec_u8_owned_closure4, map$Option_u8_u32s_owned_closure9, map$Option_u8_u8_made_closure0_closure0, inspect$Option_u8_options_closure11, mapOr$Option_u16_u8_hash_maps_closure0, mapOr$Option_u8_u8_iters_closure3, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOrElse$Option_u8_u8_options_closure7_options_closure8, okOr$Option_u32s_u8, okOr$Option_u8_u16, okOr$Option_u8_u8, okOrElse$Option_Vec_u8_String_owned_closure5, okOrElse$Option_u8_u16_options_closure12, and$Option_u8_u8, andThen$Option_u8_u8_options_closure2, filter$Option_String_owned_closure1, filter$Option_u8_combinators_closure0, or$Option_u8, orElse$Option_String_owned_closure2, orElse$Option_u8_options_closure6, xor$Option_u8, zip$Option_u8_u8, clone$Clone_Option_String } from "./core/option.ts"; import { isOkAnd$Result_u8_u16_results_closure5, isErrAnd$Result_u8_u16_results_closure6, ok$Result_u8_u16, err$Result_u8_u16, asRef$Result_u8_u16, map$Result_Vec_u8_String_Vec_u8_owned_closure6, map$Result_u8_u16_u8_options_closure13, mapOr$Result_u8_u16_u8_results_closure7, mapOrElse$Result_u8_u16_u8_results_closure8_results_closure9, mapErr$Result_u32s_u8_u16_from, mapErr$Result_u8_u16_u16_results_closure14, inspect$Result_u8_u16_results_closure12, inspectErr$Result_u8_u16_results_closure13, unwrapOrDefault$Result_u8_u16, and$Result_u8_u16_u8, andThen$Result_u8_u16_u8_results_closure3, or$Result_u8_u16_u16, orElse$Result_u8_u16_u16_results_closure4, unwrapOr$Result_u8_u16, unwrapOrElse$Result_u8_u16_results_closure11, unwrapOrElse$Result_u8_u8_panics_closure1, copied$Result_u8_u16, clone$Clone_Result_Vec_u8_String } from "./core/result.ts"; /** Run case `kind % 4` over `data`, whose bytes pick each `Some` or `None`, `Ok` or `Err`. */ @@ -27,7 +27,7 @@ export function combinators(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v } export function options(a: rt.u8 | undefined, b: rt.u8 | undefined, limit: rt.u8, out: rt.ByteVec): void { - rt.byteVecPush(out, isSomeAnd$Option_u8_options_closure0(a, (x: rt.u8): boolean => { + rt.byteVecPush(out, isSomeAnd$Option_u8_bools_closure0(a, (x: rt.u8): boolean => { rt.byteVecPush(out, 160); return x > limit; }) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 65d2d87d7..29f45817f 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -16,7 +16,7 @@ import type * as Point from "../shapes.Point.ts"; import type * as Shape from "../shapes.Shape.ts"; import type * as Short from "../splits.Short.ts"; -export function isSomeAnd$Option_u8_options_closure0(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$Option_u8_bools_closure0(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { if (self === undefined) { return false; } diff --git a/ts/fixtures/lang/expected/core/result.ts b/ts/fixtures/lang/expected/core/result.ts index 0128f8e0b..032ec9219 100644 --- a/ts/fixtures/lang/expected/core/result.ts +++ b/ts/fixtures/lang/expected/core/result.ts @@ -142,6 +142,62 @@ export function orElse$Result_u8_u16_u16_results_closure4(self: rt.Result, default_: rt.i16): rt.i16 { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_i32_i32(self: rt.Result, default_: rt.i32): rt.i32 { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_i64_i64(self: rt.Result, default_: rt.i64): rt.i64 { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_i8_i8(self: rt.Result, default_: rt.i8): rt.i8 { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_isize_isize(self: rt.Result, default_: rt.isize): rt.isize { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_u16_u16(self: rt.Result, default_: rt.u16): rt.u16 { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_u32_u32(self: rt.Result, default_: rt.u32): rt.u32 { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_u64_u64(self: rt.Result, default_: rt.u64): rt.u64 { + if (self.ok) { + return self.value; + } + return default_; +} + export function unwrapOr$Result_u8_u16(self: rt.Result, default_: rt.u8): rt.u8 { if (self.ok) { return self.value; @@ -149,6 +205,20 @@ export function unwrapOr$Result_u8_u16(self: rt.Result, default_: return default_; } +export function unwrapOr$Result_u8_u8(self: rt.Result, default_: rt.u8): rt.u8 { + if (self.ok) { + return self.value; + } + return default_; +} + +export function unwrapOr$Result_usize_usize(self: rt.Result, default_: rt.usize): rt.usize { + if (self.ok) { + return self.value; + } + return default_; +} + export function unwrapOrElse$Result_u8_u16_results_closure11(self: rt.Result, op: (a0: rt.u16) => rt.u8): rt.u8 { if (self.ok) { return self.value; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 297f168b8..6561fd200 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { atomics } from "./atomics.ts"; import { chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; import { hashMaps, sets, btreeMaps, deques, vecs, stores } from "./collections.ts"; @@ -73,7 +74,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) counts(data22, out22); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["fmt::rounding", (_232: rt.u8, _310: rt.ByteSlice, out23: rt.ByteVec): void => { rounding(out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", skips] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["wrappers::wrappers", wrappers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["edits::edits", edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["utf8::decodes", decodes] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["floats::floats", floats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::skips", skips] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["wrappers::wrappers", wrappers] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["edits::edits", edits] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["utf8::decodes", decodes] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["floats::floats", floats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["atomics::atomics", atomics] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/src/atomics.rs b/ts/fixtures/lang/src/atomics.rs new file mode 100644 index 000000000..c923a6466 --- /dev/null +++ b/ts/fixtures/lang/src/atomics.rs @@ -0,0 +1,211 @@ +//! Atomics, which one thread never races: each width's loads, stores, and +//! read-modify-writes, which wrap where arithmetic would panic, and std's panics on an +//! ordering an operation can't take, through a `&`, an `Arc`, a field, and a `&mut`. An +//! update whose callback stores to the atomic it updates retries, as std's loop does. + +use std::sync::Arc; +use std::sync::atomic::Ordering::{self, AcqRel, Acquire, Relaxed, Release, SeqCst}; +use std::sync::atomic::{ + self, AtomicBool, AtomicI8, AtomicI16, AtomicI32, AtomicI64, AtomicIsize, AtomicU8, AtomicU16, AtomicU32, + AtomicU64, AtomicUsize, +}; + +const ORDERS: [Ordering; 5] = [Relaxed, Release, Acquire, AcqRel, SeqCst]; +/// What a load, and a compare-exchange that fails, can take. +const LOADS: [Ordering; 3] = [Relaxed, Acquire, SeqCst]; +const STORES: [Ordering; 3] = [Relaxed, Release, SeqCst]; +const FENCES: [Ordering; 4] = [Release, Acquire, AcqRel, SeqCst]; + +/// An ordering from `b`: one of `valid`, or from 0xf0 on any, which may panic. +fn order(b: u8, valid: &[Ordering]) -> Ordering { + match b >= 0xf0 { + true => ORDERS[usize::from(b) % ORDERS.len()], + false => valid[usize::from(b) % valid.len()], + } +} + +/// Take an integer's big-endian bytes from the front of `data`, zero-padded. +macro_rules! take { + ($t:ty, $data:expr) => {{ + let data: &[u8] = $data; + let mut buf = [0u8; core::mem::size_of::<$t>()]; + let n = data.len().min(buf.len()); + buf[..n].copy_from_slice(&data[..n]); + (<$t>::from_be_bytes(buf), &data[n..]) + }}; +} + +macro_rules! ints { + ($($name:ident: $atomic:ident, $t:ty;)*) => {$( + /// Steps of an operation, an ordering, and an operand on one atomic, each putting + /// what it read. + fn $name(data: &[u8], out: &mut Vec) { + let (first, mut data) = take!($t, data); + let mut atomic = $atomic::new(first); + while let [op, b, rest @ ..] = data { + let (v, rest) = take!($t, rest); + data = rest; + let (b, op) = (*b, *op); + let any = order(b, &ORDERS); + let failure = order(b ^ 0x0f, &LOADS); + let old = match op % 16 { + 0 => atomic.load(order(b, &LOADS)), + 1 => { + atomic.store(v, order(b, &STORES)); + v + } + 2 => atomic.swap(v, any), + 3 => atomic.fetch_add(v, any), + 4 => atomic.fetch_sub(v, any), + 5 => atomic.fetch_and(v, any), + 6 => atomic.fetch_or(v, any), + 7 => atomic.fetch_xor(v, any), + 8 => atomic.fetch_max(v, any), + 9 => atomic.fetch_min(v, any), + 10 | 11 => { + // The value it holds, half the time, so that some succeed. + let current = if b & 1 == 0 { atomic.load(Relaxed) } else { v.wrapping_add(1) }; + let result = match op % 16 == 10 { + true => atomic.compare_exchange(current, v, any, failure), + false => atomic.compare_exchange_weak(current, v, any, failure), + }; + out.push(result.is_ok() as u8); + match result { + Ok(x) | Err(x) => x, + } + } + // Each callback stores `v` once, which its first compare-exchange then misses. + 12 => match atomic.try_update(any, failure, |x| { + out.push(0xc0); + if x != v && b & 2 == 0 { + atomic.store(v, Relaxed); + } + x.checked_add(v) + }) { + Ok(x) => x, + Err(x) => x.wrapping_add(1), + }, + 13 => atomic.update(any, failure, |x| { + out.push(0xc1); + if x != v && b & 2 == 0 { + atomic.store(v, Relaxed); + } + x.wrapping_sub(v) ^ 1 + }), + 14 => { + #[expect(deprecated, reason = "moq-net calls it")] + let r = atomic.fetch_update(any, failure, |x| (x != v).then_some(v)); + r.unwrap_or(v) + } + _ => { + // Through `&mut`, which no other reference can see change. + *atomic.get_mut() ^= v; + atomic.load(SeqCst) + } + }; + out.extend_from_slice(&old.to_be_bytes()); + } + out.extend_from_slice(&atomic.into_inner().to_be_bytes()); + } + )*}; +} + +ints! { + u8s: AtomicU8, u8; + u16s: AtomicU16, u16; + u32s: AtomicU32, u32; + u64s: AtomicU64, u64; + usizes: AtomicUsize, usize; + i8s: AtomicI8, i8; + i16s: AtomicI16, i16; + i32s: AtomicI32, i32; + i64s: AtomicI64, i64; + isizes: AtomicIsize, isize; +} + +fn bools(data: &[u8], out: &mut Vec) { + let flag = AtomicBool::new(data.first().is_some_and(|&b| b & 1 == 1)); + let mut data = data; + while let [op, b, rest @ ..] = data { + data = rest; + let (op, b) = (*op, *b); + let v = b & 1 == 1; + let any = order(b, &ORDERS); + let old = match op % 11 { + 0 => flag.load(order(b, &LOADS)), + 1 => { + flag.store(v, order(b, &STORES)); + v + } + 2 => flag.swap(v, any), + 3 => flag.fetch_and(v, any), + 4 => flag.fetch_or(v, any), + 5 => flag.fetch_xor(v, any), + 6 => flag.fetch_nand(v, any), + 7 => flag.fetch_not(any), + 8 => match flag.compare_exchange(v, !v, any, order(b ^ 0x0f, &LOADS)) { + Ok(x) => x, + Err(x) => !x, + }, + 9 => { + atomic::fence(order(b, &FENCES)); + atomic::compiler_fence(order(b ^ 0x0f, &FENCES)); + v + } + _ => flag.update(any, Relaxed, |x| { + out.push(0xc1); + if x != v { + flag.store(v, Relaxed); + } + x != v + }), + }; + out.push(old as u8); + } + out.push(flag.into_inner() as u8); +} + +/// Counters shared by `Arc`, in fields, as moq-net's stats are. +#[derive(Default)] +struct Stats { + sent: AtomicU64, + open: AtomicBool, + peers: AtomicUsize, +} + +/// A load at an ordering passed in, as moq-net's frame does. +fn sent(stats: &Stats, ord: Ordering) -> u64 { + stats.sent.load(ord) +} + +fn shared(data: &[u8], out: &mut Vec) { + let stats = Arc::new(Stats::default()); + let peer = Arc::clone(&stats); + for &b in data { + let stats = if b & 1 == 0 { &stats } else { &peer }; + stats.sent.fetch_add(u64::from(b) << 50, Relaxed); + stats.peers.fetch_sub(usize::from(b & 2 == 0), Release); + stats.open.store(b > 0x80, Release); + out.push(stats.open.load(Acquire) as u8); + } + out.extend_from_slice(&sent(&peer, order(data.len() as u8, &LOADS)).to_be_bytes()); + out.extend_from_slice(&peer.peers.load(SeqCst).to_be_bytes()); + out.push(Arc::strong_count(&stats) as u8); +} + +pub fn atomics(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 12 { + 0 => u8s(data, out), + 1 => u16s(data, out), + 2 => u32s(data, out), + 3 => u64s(data, out), + 4 => usizes(data, out), + 5 => i8s(data, out), + 6 => i16s(data, out), + 7 => i32s(data, out), + 8 => i64s(data, out), + 9 => isizes(data, out), + 10 => bools(data, out), + _ => shared(data, out), + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 3da9d59e8..0922af242 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,8 +2,8 @@ //! case and the rest is its input. use crate::{ - chars, chunks, collections, combinators, cows, durations, edits, floats, fmt, generics, ints, iters, keys, nested, - refs, shapes, splits, strs, utf8, wrappers, + atomics, chars, chunks, collections, combinators, cows, durations, edits, floats, fmt, generics, ints, iters, keys, + nested, refs, shapes, splits, strs, utf8, wrappers, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -81,6 +81,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("edits::edits", edits::edits), ("utf8::decodes", utf8::decodes), ("floats::floats", floats::floats), + ("atomics::atomics", atomics::atomics), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 1f6545e6b..feadbf48f 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -3,12 +3,13 @@ //! `Cow`, `Duration`, control flow, patterns, byte slices split apart, `Copy` //! aggregates, closures, traits, generic types, formatting, collections, UTF-8 //! decoding, `&mut` to values JS copies, the standard library calls it maps, -//! `Option`'s and `Result`'s combinators from core's MIR, and `Option`s of values that -//! can already be `undefined`. +//! `Option`'s and `Result`'s combinators from core's MIR, `Option`s of values that can +//! already be `undefined`, and atomics. //! //! `harness::run` is the entry point both sides of the differential test run, and //! `fmt::Fault` an error only `caller.ts` prints. +mod atomics; mod chars; mod chunks; mod collections; diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index 3c9fbc652..cd0d95e6b 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rt/task.ts @@ -1,10 +1,10 @@ -// Ownership and async, for rust2-ts output: what Rust's `Drop`, `Arc`, `Mutex`, and -// futures do that plain JS does not. `rt.ts` re-exports all of it. +// Ownership and async, for rust2-ts output: what Rust's `Drop`, `Arc`, `Mutex`, atomics, +// and futures do that plain JS does not. `rt.ts` re-exports all of it. // // A value whose drop JS can observe has `[Symbol.dispose]`, which runs its `Drop` impl // and drops its fields. `None` is `undefined`, which drops as nothing. -import { Panic } from "../rt.ts"; +import { Err, Ok, Panic, panic, type Place, type Result } from "../rt.ts"; // Drops @@ -134,6 +134,104 @@ export class Mutex implements Disposable { } } +// Atomics, which one thread never races: each operation reads and writes as it would +// alone, and an ordering it can't take panics as std's does. + +/** `atomic::Ordering`: its discriminant, 0 to 4 for `Relaxed`, `Release`, `Acquire`, `AcqRel`, and `SeqCst`. */ +export type AtomicOrdering = number; + +/** `Atomic` of a `bool` or an integer: the place that holds it. */ +export class Atomic implements Place { + v: T; + + constructor(v: T) { + this.v = v; + } +} + +/** `Atomic::load`. */ +export function atomicLoad(atomic: Atomic, order: AtomicOrdering): T { + if (order === 1) panic("there is no such thing as a release load"); + if (order === 3) panic("there is no such thing as an acquire-release load"); + return atomic.v; +} + +/** `Atomic::store`. */ +export function atomicStore(atomic: Atomic, value: T, order: AtomicOrdering): void { + if (order === 2) panic("there is no such thing as an acquire store"); + if (order === 3) panic("there is no such thing as an acquire-release store"); + atomic.v = value; +} + +/** `Atomic::swap`, which any ordering can do. */ +export function atomicSwap(atomic: Atomic, value: T, _order: AtomicOrdering): T { + const old = atomic.v; + atomic.v = value; + return old; +} + +/** A read-modify-write such as `Atomic::fetch_add`: the value becomes `f(old, value)`, and `old` returns. */ +export function atomicFetch(atomic: Atomic, f: (old: T, value: U) => T, value: U, _order: AtomicOrdering): T { + const old = atomic.v; + atomic.v = f(old, value); + return old; +} + +/** + * `Atomic::compare_exchange`, and `compare_exchange_weak`, which never fails spuriously + * on one thread. `eq` compares a wide integer, and `===` anything else. + */ +export function atomicCompareExchange( + atomic: Atomic, + current: T, + next: T, + _success: AtomicOrdering, + failure: AtomicOrdering, + eq?: (a: T, b: T) => boolean, +): Result { + if (failure === 3) panic("there is no such thing as an acquire-release failure ordering"); + if (failure === 1) panic("there is no such thing as a release failure ordering"); + const old = atomic.v; + if (eq === undefined ? old !== current : !eq(old, current)) return Err(old); + atomic.v = next; + return Ok(old); +} + +/** + * `Atomic::try_update`: `f` of the value it loads, compare-exchanged unless `None`, and + * again if `f` itself changed the atomic. `eq` is as `atomicCompareExchange`'s. + */ +export function atomicTryUpdate( + atomic: Atomic, + set: AtomicOrdering, + fetch: AtomicOrdering, + f: (value: T) => T | undefined, + eq?: (a: T, b: T) => boolean, +): Result { + let prev = atomicLoad(atomic, fetch); + for (let next = f(prev); next !== undefined; next = f(prev)) { + const result = atomicCompareExchange(atomic, prev, next, set, fetch, eq); + if (result.ok) return result; + prev = result.error; + } + return Err(prev); +} + +/** `Atomic::update`: `f` of the value it loads, compare-exchanged until it holds. */ +export function atomicUpdate(atomic: Atomic, set: AtomicOrdering, fetch: AtomicOrdering, f: (value: T) => T, eq?: (a: T, b: T) => boolean): T { + let prev = atomicLoad(atomic, fetch); + for (;;) { + const result = atomicCompareExchange(atomic, prev, f(prev), set, fetch, eq); + if (result.ok) return result.value; + prev = result.error; + } +} + +/** `atomic::fence` and `compiler_fence`, which order nothing on one thread. */ +export function fence(order: AtomicOrdering): void { + if (order === 0) panic("there is no such thing as a relaxed fence"); +} + // Futures /** `Poll::Pending`; `Poll::Ready(v)` is `v` itself. */ diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 7534fcbfe..099303415 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -280,8 +280,9 @@ fn undefined_arg<'tcx>(b: &Body<'_, '_, 'tcx>, std: Std, coll: Ty<'tcx>) -> Opti (0..n).map(|i| arg(coll, i)).find(|&t| b.t.erases_to(t).undefined) } -/// Whether `call` returns a `&mut`, or an `Option` of one, to a value a map holds that JS -/// copies, which its mapping returns as an `rt.Place`: `get_mut`, and an entry's. +/// Whether `call` returns a `&mut`, or an `Option` of one, to a value a map or an atomic +/// holds that JS copies, which its mapping returns as an `rt.Place`: `get_mut`, and an +/// entry's. An atomic is that place itself. pub fn place_call<'tcx>(b: &Body<'_, '_, 'tcx>, call: &Call<'tcx>) -> bool { let tcx = b.t.tcx; let Some(std) = library::inherent_std(tcx, call.def_id) else { @@ -289,20 +290,24 @@ pub fn place_call<'tcx>(b: &Body<'_, '_, 'tcx>, call: &Call<'tcx>) -> bool { }; let name = tcx.item_name(call.def_id); let coll = impl_self_ty(b, call); - let methods: &[&str] = match std { - Std::HashMap | Std::BTreeMap => &["get_mut"], - Std::Entry if is_vacant(b, coll) => &["insert"], - Std::Entry => &[ - "or_insert", - "or_insert_with", - "or_insert_with_key", - "or_default", - "get_mut", - "into_mut", - ], + let (methods, value): (&[&str], usize) = match std { + Std::HashMap | Std::BTreeMap => (&["get_mut"], 1), + Std::Entry if is_vacant(b, coll) => (&["insert"], 1), + Std::Entry => ( + &[ + "or_insert", + "or_insert_with", + "or_insert_with_key", + "or_default", + "get_mut", + "into_mut", + ], + 1, + ), + Std::Atomic => (&["get_mut"], 0), _ => return false, }; - methods.contains(&name.as_str()) && b.t.needs_place(arg(coll, 1)) + methods.contains(&name.as_str()) && b.t.needs_place(arg(coll, value)) } /// The type an inherent method's impl is of, such as `HashMap`. diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index e0484098b..413881162 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -134,6 +134,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) } (Std::Ordering, _) => super::collections::ordering_variant(variant), + (Std::AtomicOrdering, _) => super::task::atomic_ordering(variant), (Std::Bound, _) => { let ts_ty = self.t.ty(ty, span); super::library::bound(adt.variant(variant).name.as_str(), values.pop(), ts_ty) diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index c48bb16ec..dfd4c18ba 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -56,6 +56,10 @@ pub enum Std { MutexGuard, /// What a `Mutex` can't be locked with on one thread: never. PoisonError, + /// `rt.Atomic`, a place holding its `bool` or integer. + Atomic, + /// `rt.AtomicOrdering`: its discriminant. + AtomicOrdering, /// `rt.Waker`. Waker, /// `rt.Context`: its waker. @@ -142,6 +146,7 @@ impl Std { (sym::ArcWeak, Self::Weak), (sym::Mutex, Self::Mutex), (sym::MutexGuard, Self::MutexGuard), + (rustc_span::Symbol::intern("Atomic"), Self::Atomic), (rustc_span::Symbol::intern("Waker"), Self::Waker), (rustc_span::Symbol::intern("PinMacroHelper"), Self::Pin), (rustc_span::Symbol::intern("HashMap"), Self::HashMap), @@ -200,6 +205,7 @@ impl Std { ["future", "pending", "Pending"] => Some(Self::Pending), ["convert", "Infallible"] => Some(Self::Infallible), ["cmp", "Ordering"] => Some(Self::Ordering), + ["sync", "atomic", "Ordering"] => Some(Self::AtomicOrdering), ["cmp", "Reverse"] => Some(Self::Reverse), ["ops", "range", "Bound"] => Some(Self::Bound), ["num", "nonzero", "NonZero"] => Some(Self::NonZero), @@ -1662,6 +1668,10 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option Expr::Str(String::new()), Std::Cow if string(tcx, ty) => Expr::Str(String::new()), Std::Duration => super::time::zero(), + Std::Atomic => Expr::New( + Box::new(Expr::Rt("Atomic".into())), + vec![default_value(b, args.type_at(0))?], + ), _ => return None, }, _ => return None, diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index b6fa863d7..a27ffa8ca 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -908,6 +908,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(Std::Ordering) => scrut .clone() .binary("===", crate::lower::collections::ordering_variant(index)), + Some(Std::AtomicOrdering) => { + scrut.clone().binary("===", crate::lower::task::atomic_ordering(index)) + } Some(Std::Bound) => scrut .clone() .member("tag") diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index f928d9a59..bb12772cc 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -272,7 +272,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ) } // The value is its discriminant. - Some(Std::Ordering) => scrut, + Some(Std::Ordering | Std::AtomicOrdering) => scrut, Some(Std::Cow) => self.err(span, crate::lower::library::cow_variant(ty)), Some(Std::Bound) => { let table = discrs @@ -465,6 +465,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { (Std::RangeFrom, _) => Expr::Object(vec![(Key::Name("start".into()), values.pop().unwrap())]), (Std::RangeFull, _) => Expr::undefined(), (Std::Ordering, _) => crate::lower::collections::ordering_variant(variant), + (Std::AtomicOrdering, _) => crate::lower::task::atomic_ordering(variant), (Std::ControlFlow, _) => super::call::control_flow(self, ty, variant, values), (Std::Range, _) => { let ty::Adt(_, gargs) = ty.kind() else { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 55d3dd480..0a9953372 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -952,6 +952,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { | library::Std::Weak | library::Std::Mutex | library::Std::MutexGuard + | library::Std::Atomic | library::Std::Waker | library::Std::Context | library::Std::Pin @@ -1220,6 +1221,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Type::Rt("Mutex", vec![self.ty(inner, span)]) } library::Std::PoisonError => Type::Builtin("never"), + library::Std::Atomic => Type::Rt("Atomic", vec![self.ty(args.type_at(0), span)]), + library::Std::AtomicOrdering => Type::Rt("AtomicOrdering", vec![]), library::Std::Waker => Type::Rt("Waker", vec![]), library::Std::Context => Type::Rt("Context", vec![]), library::Std::Poll => { diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index 21bde2cf2..b86ec68f5 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -1,12 +1,15 @@ //! The standard library's ownership and async types, as `rt/task.ts` gives them: `Arc`, -//! `Weak`, `Mutex`, `Waker`, `Context`, `Poll`, `Pin`, and std's futures. +//! `Weak`, `Mutex`, atomics, `Waker`, `Context`, `Poll`, `Pin`, and std's futures. +use rustc_abi::VariantIdx; +use rustc_middle::mir::{BinOp, UnOp}; use rustc_middle::ty::{self, Instance, Ty}; use rustc_span::{Span, Symbol}; use super::Translator; use super::body::Body; use super::library::{self, Call, Std}; +use super::num::{self, Int, Operand}; use crate::ts::{Expr, Param, Stmt}; impl<'tcx> Translator<'_, 'tcx> { @@ -175,6 +178,8 @@ pub fn call<'tcx>( ("Result", "unwrap" | "expect") if call.args.types().nth(1).and_then(std_of) == Some(Std::PoisonError) => { first(args) } + ("Atomic", _) => return atomic(b, call, name, args), + ("atomic", "fence" | "compiler_fence") => Expr::rt("fence", args), ("Waker", "wake_by_ref") => first(args).member("wakeByRef").call(vec![]), ("Waker", "wake") => first(args).member("wake").call(vec![]), ("Waker", "will_wake") => { @@ -234,6 +239,93 @@ pub fn call<'tcx>( Ok(Some(e)) } +/// An `Atomic` method: an `rt.Atomic`'s, with its orderings, which the runtime checks. +/// `Ok(None)` refuses it. +fn atomic<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + call: &Call<'tcx>, + name: &str, + args: Vec, +) -> Result, Vec> { + let tcx = b.t.tcx; + let imp = tcx.inherent_impl_of_assoc(call.def_id).expect("an inherent method"); + let ty::Adt(_, impl_args) = tcx.type_of(imp).instantiate_identity().skip_norm_wip().kind() else { + unreachable!("an atomic is a struct") + }; + let ty = impl_args.type_at(0); + let int = Int::of(ty); + let fetch = |f: Expr, mut args: Vec| { + args.insert(1, f); + Expr::rt("atomicFetch", args) + }; + // A compare-exchange, given what compares a wide integer, whose limbs `===` can't. + let exchange = |f: &str, mut args: Vec| { + args.extend(int.filter(|int| int.big()).map(|int| int.func("eq"))); + Expr::rt(f, args) + }; + let e = match name { + "new" => Expr::New(Box::new(Expr::Rt("Atomic".into())), args), + "load" => Expr::rt("atomicLoad", args), + "store" => Expr::rt("atomicStore", args), + "swap" => Expr::rt("atomicSwap", args), + "into_inner" => first(args).member("v"), + // The atomic is the place that holds its value. + "get_mut" => first(args), + "compare_exchange" | "compare_exchange_weak" => exchange("atomicCompareExchange", args), + "fetch_add" if let Some(int) = int => fetch(int.func("wrappingAdd"), args), + "fetch_sub" if let Some(int) = int => fetch(int.func("wrappingSub"), args), + "fetch_max" | "fetch_min" if let Some(int) = int => { + let f = match int.big() { + true => int.func(&name[6..]), + false => Expr::Rt(name[6..].into()), + }; + fetch(f, args) + } + "fetch_and" | "fetch_or" | "fetch_xor" | "fetch_nand" => { + let op = match name { + "fetch_and" | "fetch_nand" => BinOp::BitAnd, + "fetch_or" => BinOp::BitOr, + _ => BinOp::BitXor, + }; + fetch(binary(b, op, name == "fetch_nand", ty, call.span), args) + } + // `fetch_xor(true)`, as std's is. + "fetch_not" if ty.is_bool() => { + let f = binary(b, BinOp::BitXor, false, ty, call.span); + let mut args = args; + args.insert(1, Expr::lit("true")); + fetch(f, args) + } + // std's loop of compare-exchanges, which retries only if `f` changed the atomic. + "try_update" | "fetch_update" => exchange("atomicTryUpdate", args), + "update" => exchange("atomicUpdate", args), + _ => return Ok(None), + }; + Ok(Some(e)) +} + +/// `(old, value) => old op value` over `ty`, negated if `not`. +fn binary<'tcx>(b: &mut Body<'_, '_, 'tcx>, op: BinOp, not: bool, ty: Ty<'tcx>, span: Span) -> Expr { + let operand = |name: &str| Operand { + expr: Expr::ident(name), + value: None, + }; + let mut value = num::binary(b, op, operand("old"), operand("value"), ty, ty, span); + if not { + value = num::unary(b, UnOp::Not, value, ty, span); + } + let params = ["old", "value"].map(|name| Param { + name: name.into(), + ty: None, + }); + Expr::Lambda(params.into(), Box::new(value)) +} + +/// The `atomic::Ordering` variant `index`: its discriminant. +pub fn atomic_ordering(index: VariantIdx) -> Expr { + Expr::lit(index.as_u32().to_string()) +} + /// `Waker::from(arc)`, an `Arc`: an `rt.ArcWaker` over `W`'s `Wake::wake`, what drops /// the `Arc`, and `W`'s own `wake_by_ref` if it overrides the default. fn arc_waker<'tcx>(b: &mut Body<'_, '_, 'tcx>, arc: Ty<'tcx>, value: Expr, span: Span) -> Expr {