XADD

LOCK XADD is the atomic fetch-and-add: it adds a register to memory and hands back the value the memory held before, in one indivisible step. GCC 14 and Clang 23 at -O2 compile C’s atomic_fetch_add to it when the old value is used, and atomic_fetch_sub to a NEG of the operand followed by LOCK XADD. When the old value is not needed, both emit a plain LOCK ADD instead, and when only “did it reach zero” matters, as in dropping a reference count, they subtract with LOCK SUB (GCC) or LOCK DEC (Clang) and test ZF.

Typical uses:

• counters and statistics that several threads update;
• handing out slots, such as the next free index of a shared buffer: each thread gets a different old value;
• ticket locks: a thread takes a ticket with LOCK XADD on the next ticket number and spins, with PAUSE, until the number being served equals it.

Things to know:

• The flags are those of the addition, so they describe the new value, not the old one that the register receives.
• Only the LOCK form is atomic with respect to other processors, and LOCK needs a memory destination (#UD otherwise).
• A locked instruction is also a full barrier. By both vendors' manuals, loads and stores are not reordered with it, so a sequentially consistent fetch-and-add needs no extra fence.
• With both operands the same register, the register ends up with the sum, twice its old value, as Zen 5 and the Intel processor recorded.
• As with CMPXCHG, an operand that crosses a cache-line boundary makes the processor lock the bus; keep it naturally aligned.

CMPXCHG covers the atomic updates that have no instruction of their own, XCHG swaps without adding, and CMPccXADD adds only when a comparison holds. AADD adds to memory atomically without returning the old value and without ordering other memory accesses.

Forms

Latency and throughput

Operation

What the forms do, in pseudocode that our tests run against results recorded on real processors. How to read.

a = dest.read()                  # with LOCK: one atomic read-modify-write
b = src.read()
flags = add_flags(a, b)
src.write(a)                     # when dest and src are one register,
dest.write(a + b)                # the sum, written last, is what stays

Operands

Flags

Attributes

What else XED records about the forms. How to read.

Memory forms without LOCK

accepts a LOCK prefix

LOCK forms

locked: atomic read-modify-write; accepts XACQUIRE; accepts XRELEASE

CPUID and processors

Each form belongs to an XED ISA set. A form can be used when the processor reports every CPUID bit of one of its ISA set's alternatives.

More General-purpose instructions

• NEG
• NOP
• NOT
• OR
• OUT
• OUTS
• PAUSE
• POP
• POPA
• POPF
• PUSH
• PUSHA
• PUSHF
• RCL
• RCR
• RET
• ROL
• ROR
• SALC
• SAR
• SBB
• SCAS
• SETcc
• SHL
• SHLD
• SHR
• SHRD
• STC
• STD
• STI
• STOS
• SUB
• TEST
• UD0
• UD1
• UD2
• UDB
• XCHG
• XLAT
• XOR

All 109 General-purpose instructions