arch

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 8, 2026 License: MIT Imports: 1 Imported by: 0

Documentation

Overview

Package arch provides architecture-specific atomic primitives with explicit memory ordering.

This is an internal package that implements the low-level atomic operations for different CPU architectures. Higher-level types in the parent atomix package build on these primitives.

Architecture Support

The package provides optimized implementations for:

  • amd64: x86-64 with TSO (Total Store Ordering)
  • arm64: ARM64 with LSE (Large System Extensions)
  • riscv64: RISC-V 64-bit with LL/SC atomics
  • loong64: LoongArch 64-bit with LL/SC atomics

All other architectures fall back to sync/atomic which provides sequential consistency (equivalent to AcqRel ordering).

Memory Ordering

All functions include a memory ordering suffix:

  • Relaxed: No ordering guarantees, fastest
  • Acquire: Loads after this see stores before a paired Release
  • Release: Stores before this are visible after a paired Acquire
  • AcqRel: Both Acquire and Release semantics (for RMW operations)

Implementation Strategy

The implementation uses different strategies per architecture:

x86-64 (TSO): 

x86-64's Total Store Ordering provides strong guarantees that make
all load/store orderings equivalent. Plain memory access is atomic
for aligned values, so Load and Store operations are implemented as
pure Go functions for inlining. Only read-modify-write operations
(Swap, CAS, Add) require assembly with LOCK prefix or XCHG.

ARM64: 

ARM64 has weak ordering requiring explicit acquire/release instructions.
- Relaxed Load/Store: Plain memory access (inlinable pure Go)
- Acquire Load: LDAR instruction (assembly)
- Release Store: STLR instruction (assembly)
- RMW operations: LSE instructions with ordering (assembly)

RISC-V64 / LoongArch64: 

These architectures have weak ordering and all atomic operations require
explicit fence instructions. All operations are implemented in assembly:
- RISC-V: Uses AMO instructions with .aq/.rl suffixes, or LR/SC loops
- LoongArch: Uses AM* instructions, or LL/SC loops with DBAR barriers

128-bit Atomics

128-bit operations are available on all supported architectures:

  • amd64: CMPXCHG16B instruction (requires 16-byte alignment)
  • arm64: LDXP/STXP (default) or CASP with -tags=lse2 for ARMv8.4+
  • riscv64/loong64: Emulated via LL/SC on low 64 bits with full barrier

Inlining Optimization

To enable inlining for hot-path operations, load/store functions are split into separate files:

  • loadstore_amd64.go: Pure Go implementations for x86-64 TSO
  • loadstore_arm64.go: Pure Go relaxed implementations for ARM64

Assembly stubs are only used where hardware instructions with ordering are required, marked with //go:noescape to prevent escape analysis overhead.

Function Naming Convention 

<Op><Type><Ordering>

Where:

  • Op: Load, Store, Swap, Cas, Cax, Add, And, Or, Xor
  • Type: Int32, Uint32, Int64, Uint64, Uintptr, Pointer, Uint128
  • Ordering: Relaxed, Acquire, Release, AcqRel

Cas returns bool (success), Cax returns old value (compare-exchange). Add returns the new value. Swap/And/Or/Xor return the previous value.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AddInt32AcqRel 

func AddInt32AcqRel(addr *int32, delta int32) int32

func AddInt32Acquire 

func AddInt32Acquire(addr *int32, delta int32) int32

func AddInt32Relaxed 

func AddInt32Relaxed(addr *int32, delta int32) int32

Add atomically adds delta and returns the new value.

func AddInt32Release 

func AddInt32Release(addr *int32, delta int32) int32

func AddInt64AcqRel 

func AddInt64AcqRel(addr *int64, delta int64) int64

func AddInt64Acquire 

func AddInt64Acquire(addr *int64, delta int64) int64

func AddInt64Relaxed 

func AddInt64Relaxed(addr *int64, delta int64) int64

func AddInt64Release 

func AddInt64Release(addr *int64, delta int64) int64

func AddUint32AcqRel 

func AddUint32AcqRel(addr *uint32, delta uint32) uint32

func AddUint32Acquire 

func AddUint32Acquire(addr *uint32, delta uint32) uint32

func AddUint32Relaxed 

func AddUint32Relaxed(addr *uint32, delta uint32) uint32

func AddUint32Release 

func AddUint32Release(addr *uint32, delta uint32) uint32

func AddUint64AcqRel 

func AddUint64AcqRel(addr *uint64, delta uint64) uint64

func AddUint64Acquire 

func AddUint64Acquire(addr *uint64, delta uint64) uint64

func AddUint64Relaxed 

func AddUint64Relaxed(addr *uint64, delta uint64) uint64

func AddUint64Release 

func AddUint64Release(addr *uint64, delta uint64) uint64

func AddUintptrAcqRel 

func AddUintptrAcqRel(addr *uintptr, delta uintptr) uintptr

func AddUintptrAcquire 

func AddUintptrAcquire(addr *uintptr, delta uintptr) uintptr

func AddUintptrRelaxed 

func AddUintptrRelaxed(addr *uintptr, delta uintptr) uintptr

func AddUintptrRelease 

func AddUintptrRelease(addr *uintptr, delta uintptr) uintptr

func AndInt32AcqRel 

func AndInt32AcqRel(addr *int32, mask int32) int32

func AndInt32Acquire 

func AndInt32Acquire(addr *int32, mask int32) int32

func AndInt32Relaxed 

func AndInt32Relaxed(addr *int32, mask int32) int32

And atomically performs *addr &= mask and returns the old value.

func AndInt32Release 

func AndInt32Release(addr *int32, mask int32) int32

func AndInt64AcqRel 

func AndInt64AcqRel(addr *int64, mask int64) int64

func AndInt64Acquire 

func AndInt64Acquire(addr *int64, mask int64) int64

func AndInt64Relaxed 

func AndInt64Relaxed(addr *int64, mask int64) int64

func AndInt64Release 

func AndInt64Release(addr *int64, mask int64) int64

func AndUint32AcqRel 

func AndUint32AcqRel(addr *uint32, mask uint32) uint32

func AndUint32Acquire 

func AndUint32Acquire(addr *uint32, mask uint32) uint32

func AndUint32Relaxed 

func AndUint32Relaxed(addr *uint32, mask uint32) uint32

func AndUint32Release 

func AndUint32Release(addr *uint32, mask uint32) uint32

func AndUint64AcqRel 

func AndUint64AcqRel(addr *uint64, mask uint64) uint64

func AndUint64Acquire 

func AndUint64Acquire(addr *uint64, mask uint64) uint64

func AndUint64Relaxed 

func AndUint64Relaxed(addr *uint64, mask uint64) uint64

func AndUint64Release 

func AndUint64Release(addr *uint64, mask uint64) uint64

func AndUintptrAcqRel 

func AndUintptrAcqRel(addr *uintptr, mask uintptr) uintptr

func AndUintptrAcquire 

func AndUintptrAcquire(addr *uintptr, mask uintptr) uintptr

func AndUintptrRelaxed 

func AndUintptrRelaxed(addr *uintptr, mask uintptr) uintptr

func AndUintptrRelease 

func AndUintptrRelease(addr *uintptr, mask uintptr) uintptr

func BarrierAcqRel 

func BarrierAcqRel()

func BarrierAcquire 

func BarrierAcquire()

func BarrierRelease 

func BarrierRelease()

func CasInt32AcqRel 

func CasInt32AcqRel(addr *int32, old, new int32) bool

func CasInt32Acquire 

func CasInt32Acquire(addr *int32, old, new int32) bool

func CasInt32Relaxed 

func CasInt32Relaxed(addr *int32, old, new int32) bool

Cas atomically compares *addr with old and swaps if equal. Returns true if the swap occurred.

func CasInt32Release 

func CasInt32Release(addr *int32, old, new int32) bool

func CasInt64AcqRel 

func CasInt64AcqRel(addr *int64, old, new int64) bool

func CasInt64Acquire 

func CasInt64Acquire(addr *int64, old, new int64) bool

func CasInt64Relaxed 

func CasInt64Relaxed(addr *int64, old, new int64) bool

func CasInt64Release 

func CasInt64Release(addr *int64, old, new int64) bool

func CasPointerAcqRel 

func CasPointerAcqRel(addr *unsafe.Pointer, old, new unsafe.Pointer) bool

func CasPointerAcquire 

func CasPointerAcquire(addr *unsafe.Pointer, old, new unsafe.Pointer) bool

func CasPointerRelaxed 

func CasPointerRelaxed(addr *unsafe.Pointer, old, new unsafe.Pointer) bool

func CasPointerRelease 

func CasPointerRelease(addr *unsafe.Pointer, old, new unsafe.Pointer) bool

func CasUint128AcqRel 

func CasUint128AcqRel(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) bool

func CasUint128Acquire 

func CasUint128Acquire(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) bool

func CasUint128Relaxed 

func CasUint128Relaxed(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) bool

func CasUint128Release 

func CasUint128Release(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) bool

func CasUint32AcqRel 

func CasUint32AcqRel(addr *uint32, old, new uint32) bool

func CasUint32Acquire 

func CasUint32Acquire(addr *uint32, old, new uint32) bool

func CasUint32Relaxed 

func CasUint32Relaxed(addr *uint32, old, new uint32) bool

func CasUint32Release 

func CasUint32Release(addr *uint32, old, new uint32) bool

func CasUint64AcqRel 

func CasUint64AcqRel(addr *uint64, old, new uint64) bool

func CasUint64Acquire 

func CasUint64Acquire(addr *uint64, old, new uint64) bool

func CasUint64Relaxed 

func CasUint64Relaxed(addr *uint64, old, new uint64) bool

func CasUint64Release 

func CasUint64Release(addr *uint64, old, new uint64) bool

func CasUintptrAcqRel 

func CasUintptrAcqRel(addr *uintptr, old, new uintptr) bool

func CasUintptrAcquire 

func CasUintptrAcquire(addr *uintptr, old, new uintptr) bool

func CasUintptrRelaxed 

func CasUintptrRelaxed(addr *uintptr, old, new uintptr) bool

func CasUintptrRelease 

func CasUintptrRelease(addr *uintptr, old, new uintptr) bool

func CaxInt32AcqRel 

func CaxInt32AcqRel(addr *int32, old, new int32) int32

func CaxInt32Acquire 

func CaxInt32Acquire(addr *int32, old, new int32) int32

func CaxInt32Relaxed 

func CaxInt32Relaxed(addr *int32, old, new int32) int32

Cax atomically compares *addr with old and swaps if equal. Returns the previous value (compare-exchange).

func CaxInt32Release 

func CaxInt32Release(addr *int32, old, new int32) int32

func CaxInt64AcqRel 

func CaxInt64AcqRel(addr *int64, old, new int64) int64

func CaxInt64Acquire 

func CaxInt64Acquire(addr *int64, old, new int64) int64

func CaxInt64Relaxed 

func CaxInt64Relaxed(addr *int64, old, new int64) int64

func CaxInt64Release 

func CaxInt64Release(addr *int64, old, new int64) int64

func CaxPointerAcqRel 

func CaxPointerAcqRel(addr *unsafe.Pointer, old, new unsafe.Pointer) unsafe.Pointer

func CaxPointerAcquire 

func CaxPointerAcquire(addr *unsafe.Pointer, old, new unsafe.Pointer) unsafe.Pointer

func CaxPointerRelaxed 

func CaxPointerRelaxed(addr *unsafe.Pointer, old, new unsafe.Pointer) unsafe.Pointer

func CaxPointerRelease 

func CaxPointerRelease(addr *unsafe.Pointer, old, new unsafe.Pointer) unsafe.Pointer

func CaxUint128AcqRel 

func CaxUint128AcqRel(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

func CaxUint128Acquire 

func CaxUint128Acquire(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

func CaxUint128Relaxed 

func CaxUint128Relaxed(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

func CaxUint128Release 

func CaxUint128Release(addr *[16]byte, oldLo, oldHi, newLo, newHi uint64) (lo, hi uint64)

func CaxUint32AcqRel 

func CaxUint32AcqRel(addr *uint32, old, new uint32) uint32

func CaxUint32Acquire 

func CaxUint32Acquire(addr *uint32, old, new uint32) uint32

func CaxUint32Relaxed 

func CaxUint32Relaxed(addr *uint32, old, new uint32) uint32

func CaxUint32Release 

func CaxUint32Release(addr *uint32, old, new uint32) uint32

func CaxUint64AcqRel 

func CaxUint64AcqRel(addr *uint64, old, new uint64) uint64

func CaxUint64Acquire 

func CaxUint64Acquire(addr *uint64, old, new uint64) uint64

func CaxUint64Relaxed 

func CaxUint64Relaxed(addr *uint64, old, new uint64) uint64

func CaxUint64Release 

func CaxUint64Release(addr *uint64, old, new uint64) uint64

func CaxUintptrAcqRel 

func CaxUintptrAcqRel(addr *uintptr, old, new uintptr) uintptr

func CaxUintptrAcquire 

func CaxUintptrAcquire(addr *uintptr, old, new uintptr) uintptr

func CaxUintptrRelaxed 

func CaxUintptrRelaxed(addr *uintptr, old, new uintptr) uintptr

func CaxUintptrRelease 

func CaxUintptrRelease(addr *uintptr, old, new uintptr) uintptr

func LoadInt32Acquire 

func LoadInt32Acquire(addr *int32) int32

LoadInt32Acquire atomically loads *addr with acquire memory ordering. On x86-64 TSO, this is equivalent to relaxed ordering.

func LoadInt32Relaxed 

func LoadInt32Relaxed(addr *int32) int32

LoadInt32Relaxed atomically loads *addr with relaxed memory ordering.

func LoadInt64Acquire 

func LoadInt64Acquire(addr *int64) int64

LoadInt64Acquire atomically loads *addr with acquire memory ordering.

func LoadInt64Relaxed 

func LoadInt64Relaxed(addr *int64) int64

LoadInt64Relaxed atomically loads *addr with relaxed memory ordering.

func LoadPointerAcquire 

func LoadPointerAcquire(addr *unsafe.Pointer) unsafe.Pointer

LoadPointerAcquire atomically loads *addr with acquire memory ordering.

func LoadPointerRelaxed 

func LoadPointerRelaxed(addr *unsafe.Pointer) unsafe.Pointer

LoadPointerRelaxed atomically loads *addr with relaxed memory ordering.

func LoadUint128Acquire 

func LoadUint128Acquire(addr *[16]byte) (lo, hi uint64)

func LoadUint128Relaxed 

func LoadUint128Relaxed(addr *[16]byte) (lo, hi uint64)

func LoadUint32Acquire 

func LoadUint32Acquire(addr *uint32) uint32

LoadUint32Acquire atomically loads *addr with acquire memory ordering.

func LoadUint32Relaxed 

func LoadUint32Relaxed(addr *uint32) uint32

LoadUint32Relaxed atomically loads *addr with relaxed memory ordering.

func LoadUint64Acquire 

func LoadUint64Acquire(addr *uint64) uint64

LoadUint64Acquire atomically loads *addr with acquire memory ordering.

func LoadUint64Relaxed 

func LoadUint64Relaxed(addr *uint64) uint64

LoadUint64Relaxed atomically loads *addr with relaxed memory ordering.

func LoadUintptrAcquire 

func LoadUintptrAcquire(addr *uintptr) uintptr

LoadUintptrAcquire atomically loads *addr with acquire memory ordering.

func LoadUintptrRelaxed 

func LoadUintptrRelaxed(addr *uintptr) uintptr

LoadUintptrRelaxed atomically loads *addr with relaxed memory ordering.

func OrInt32AcqRel 

func OrInt32AcqRel(addr *int32, mask int32) int32

func OrInt32Acquire 

func OrInt32Acquire(addr *int32, mask int32) int32

func OrInt32Relaxed 

func OrInt32Relaxed(addr *int32, mask int32) int32

Or atomically performs *addr |= mask and returns the old value.

func OrInt32Release 

func OrInt32Release(addr *int32, mask int32) int32

func OrInt64AcqRel 

func OrInt64AcqRel(addr *int64, mask int64) int64

func OrInt64Acquire 

func OrInt64Acquire(addr *int64, mask int64) int64

func OrInt64Relaxed 

func OrInt64Relaxed(addr *int64, mask int64) int64

func OrInt64Release 

func OrInt64Release(addr *int64, mask int64) int64

func OrUint32AcqRel 

func OrUint32AcqRel(addr *uint32, mask uint32) uint32

func OrUint32Acquire 

func OrUint32Acquire(addr *uint32, mask uint32) uint32

func OrUint32Relaxed 

func OrUint32Relaxed(addr *uint32, mask uint32) uint32

func OrUint32Release 

func OrUint32Release(addr *uint32, mask uint32) uint32

func OrUint64AcqRel 

func OrUint64AcqRel(addr *uint64, mask uint64) uint64

func OrUint64Acquire 

func OrUint64Acquire(addr *uint64, mask uint64) uint64

func OrUint64Relaxed 

func OrUint64Relaxed(addr *uint64, mask uint64) uint64

func OrUint64Release 

func OrUint64Release(addr *uint64, mask uint64) uint64

func OrUintptrAcqRel 

func OrUintptrAcqRel(addr *uintptr, mask uintptr) uintptr

func OrUintptrAcquire 

func OrUintptrAcquire(addr *uintptr, mask uintptr) uintptr

func OrUintptrRelaxed 

func OrUintptrRelaxed(addr *uintptr, mask uintptr) uintptr

func OrUintptrRelease 

func OrUintptrRelease(addr *uintptr, mask uintptr) uintptr

func StoreInt32Relaxed 

func StoreInt32Relaxed(addr *int32, val int32)

StoreInt32Relaxed atomically stores val to *addr with relaxed memory ordering.

func StoreInt32Release 

func StoreInt32Release(addr *int32, val int32)

StoreInt32Release atomically stores val to *addr with release memory ordering. On x86-64 TSO, this is equivalent to relaxed ordering.

func StoreInt64Relaxed 

func StoreInt64Relaxed(addr *int64, val int64)

StoreInt64Relaxed atomically stores val to *addr with relaxed memory ordering.

func StoreInt64Release 

func StoreInt64Release(addr *int64, val int64)

StoreInt64Release atomically stores val to *addr with release memory ordering.

func StorePointerRelaxed 

func StorePointerRelaxed(addr *unsafe.Pointer, val unsafe.Pointer)

StorePointerRelaxed atomically stores val to *addr with relaxed memory ordering.

func StorePointerRelease 

func StorePointerRelease(addr *unsafe.Pointer, val unsafe.Pointer)

StorePointerRelease atomically stores val to *addr with release memory ordering.

func StoreUint128Relaxed 

func StoreUint128Relaxed(addr *[16]byte, lo, hi uint64)

func StoreUint128Release 

func StoreUint128Release(addr *[16]byte, lo, hi uint64)

func StoreUint32Relaxed 

func StoreUint32Relaxed(addr *uint32, val uint32)

StoreUint32Relaxed atomically stores val to *addr with relaxed memory ordering.

func StoreUint32Release 

func StoreUint32Release(addr *uint32, val uint32)

StoreUint32Release atomically stores val to *addr with release memory ordering.

func StoreUint64Relaxed 

func StoreUint64Relaxed(addr *uint64, val uint64)

StoreUint64Relaxed atomically stores val to *addr with relaxed memory ordering.

func StoreUint64Release 

func StoreUint64Release(addr *uint64, val uint64)

StoreUint64Release atomically stores val to *addr with release memory ordering.

func StoreUintptrRelaxed 

func StoreUintptrRelaxed(addr *uintptr, val uintptr)

StoreUintptrRelaxed atomically stores val to *addr with relaxed memory ordering.

func StoreUintptrRelease 

func StoreUintptrRelease(addr *uintptr, val uintptr)

StoreUintptrRelease atomically stores val to *addr with release memory ordering.

func SwapInt32AcqRel 

func SwapInt32AcqRel(addr *int32, new int32) int32

func SwapInt32Acquire 

func SwapInt32Acquire(addr *int32, new int32) int32

func SwapInt32Relaxed 

func SwapInt32Relaxed(addr *int32, new int32) int32

Swap atomically stores new and returns the old value.

func SwapInt32Release 

func SwapInt32Release(addr *int32, new int32) int32

func SwapInt64AcqRel 

func SwapInt64AcqRel(addr *int64, new int64) int64

func SwapInt64Acquire 

func SwapInt64Acquire(addr *int64, new int64) int64

func SwapInt64Relaxed 

func SwapInt64Relaxed(addr *int64, new int64) int64

func SwapInt64Release 

func SwapInt64Release(addr *int64, new int64) int64

func SwapPointerAcqRel 

func SwapPointerAcqRel(addr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer

func SwapPointerAcquire 

func SwapPointerAcquire(addr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer

func SwapPointerRelaxed 

func SwapPointerRelaxed(addr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer

func SwapPointerRelease 

func SwapPointerRelease(addr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer

func SwapUint128AcqRel 

func SwapUint128AcqRel(addr *[16]byte, newLo, newHi uint64) (oldLo, oldHi uint64)

func SwapUint128Acquire 

func SwapUint128Acquire(addr *[16]byte, newLo, newHi uint64) (oldLo, oldHi uint64)

func SwapUint128Relaxed 

func SwapUint128Relaxed(addr *[16]byte, newLo, newHi uint64) (oldLo, oldHi uint64)

func SwapUint128Release 

func SwapUint128Release(addr *[16]byte, newLo, newHi uint64) (oldLo, oldHi uint64)

func SwapUint32AcqRel 

func SwapUint32AcqRel(addr *uint32, new uint32) uint32

func SwapUint32Acquire 

func SwapUint32Acquire(addr *uint32, new uint32) uint32

func SwapUint32Relaxed 

func SwapUint32Relaxed(addr *uint32, new uint32) uint32

func SwapUint32Release 

func SwapUint32Release(addr *uint32, new uint32) uint32

func SwapUint64AcqRel 

func SwapUint64AcqRel(addr *uint64, new uint64) uint64

func SwapUint64Acquire 

func SwapUint64Acquire(addr *uint64, new uint64) uint64

func SwapUint64Relaxed 

func SwapUint64Relaxed(addr *uint64, new uint64) uint64

func SwapUint64Release 

func SwapUint64Release(addr *uint64, new uint64) uint64

func SwapUintptrAcqRel 

func SwapUintptrAcqRel(addr *uintptr, new uintptr) uintptr

func SwapUintptrAcquire 

func SwapUintptrAcquire(addr *uintptr, new uintptr) uintptr

func SwapUintptrRelaxed 

func SwapUintptrRelaxed(addr *uintptr, new uintptr) uintptr

func SwapUintptrRelease 

func SwapUintptrRelease(addr *uintptr, new uintptr) uintptr

func XorInt32AcqRel 

func XorInt32AcqRel(addr *int32, mask int32) int32

func XorInt32Acquire 

func XorInt32Acquire(addr *int32, mask int32) int32

func XorInt32Relaxed 

func XorInt32Relaxed(addr *int32, mask int32) int32

Xor atomically performs *addr ^= mask and returns the old value.

func XorInt32Release 

func XorInt32Release(addr *int32, mask int32) int32

func XorInt64AcqRel 

func XorInt64AcqRel(addr *int64, mask int64) int64

func XorInt64Acquire 

func XorInt64Acquire(addr *int64, mask int64) int64

func XorInt64Relaxed 

func XorInt64Relaxed(addr *int64, mask int64) int64

func XorInt64Release 

func XorInt64Release(addr *int64, mask int64) int64

func XorUint32AcqRel 

func XorUint32AcqRel(addr *uint32, mask uint32) uint32

func XorUint32Acquire 

func XorUint32Acquire(addr *uint32, mask uint32) uint32

func XorUint32Relaxed 

func XorUint32Relaxed(addr *uint32, mask uint32) uint32

func XorUint32Release 

func XorUint32Release(addr *uint32, mask uint32) uint32

func XorUint64AcqRel 

func XorUint64AcqRel(addr *uint64, mask uint64) uint64

func XorUint64Acquire 

func XorUint64Acquire(addr *uint64, mask uint64) uint64

func XorUint64Relaxed 

func XorUint64Relaxed(addr *uint64, mask uint64) uint64

func XorUint64Release 

func XorUint64Release(addr *uint64, mask uint64) uint64

func XorUintptrAcqRel 

func XorUintptrAcqRel(addr *uintptr, mask uintptr) uintptr

func XorUintptrAcquire 

func XorUintptrAcquire(addr *uintptr, mask uintptr) uintptr

func XorUintptrRelaxed 

func XorUintptrRelaxed(addr *uintptr, mask uintptr) uintptr

func XorUintptrRelease 

func XorUintptrRelease(addr *uintptr, mask uintptr) uintptr

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.