// Atomics — `Atomic($T)` wrapper + `Ordering`, over the compiler's atomic
// load/store (later: rmw/cas/fence) IR ops. Consumers reach these through
// std.sx (`Atomic` / `Ordering` re-exports), never by importing this file.
//
// Atomicity is a property of the OPERATION, not the storage: `Atomic(T)` is a
// transparent 1-field wrapper with `T`'s exact layout/size/align. The ops are
// `#builtin` intrinsics recognized by name at lower-time
// (`tryLowerAtomicIntrinsic`, src/ir/lower/call.zig) and emitted as dedicated
// atomic IR ops; the `Ordering` argument MUST be a constant enum literal.
#import "modules/std/core.sx";

Ordering :: enum {
    relaxed;   // → LLVM Monotonic
    acquire;   // → LLVM Acquire
    release;   // → LLVM Release
    acq_rel;   // → LLVM AcquireRelease
    seq_cst;   // → LLVM SequentiallyConsistent
}

// Compiler intrinsics. Not called directly by users — `Atomic(T)`'s methods
// forward to them. Recognized by name in lowering; the `Ordering` arg MUST be a
// constant enum literal (a non-literal is a loud diagnostic).
atomic_load  :: ($T: Type, ptr: *T, o: Ordering) -> T #builtin;
atomic_store :: ($T: Type, ptr: *T, v: T, o: Ordering) #builtin;

// NOTE (A.0): the methods bake a literal `.seq_cst` (strongest, conservative)
// rather than taking an `o: Ordering` parameter. A runtime ordering param can't
// reach the intrinsic as the compile-time constant LLVM requires, and comptime
// enum value params don't exist yet — so explicit orderings (`a.load(.acquire)`)
// land in A.0.5 once that capability does. See current/PLAN-ATOMICS.md.
Atomic :: struct ($T: Type) {
    value: T;

    init :: (v: T) -> Atomic(T) {
        return .{ value = v };
    }

    load :: (self: *Atomic(T)) -> T {
        return atomic_load(T, @self.value, .seq_cst);
    }

    store :: (self: *Atomic(T), v: T) {
        atomic_store(T, @self.value, v, .seq_cst);
    }
}