// 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;

// The ordering is a COMPTIME value param (`$o`): it must be known at compile
// time because LLVM atomic ordering is an instruction attribute, not a runtime
// operand. It is explicit (Rust-style — no default), so the caller always states
// the ordering: `a.load(.acquire)`, `a.store(v, .release)`. An invalid
// combination (`a.load(.release)`) is a compile error.
Atomic :: struct ($T: Type) {
    value: T;

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

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

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