// Atomics and carry-extending multi-word arithmetic: exchange,
// compare-exchange, exchange-add, ADCX/ADOX and the CRC-32 accumulator
// family.  Every result is folded back so no instruction is dead.

#include "textflag.h"

// func xchg(p *uint64, v uint64) uint64
TEXT ·xchg(SB), NOSPLIT, $0-24
	MOVQ  p+0(FP), AX
	MOVQ  v+8(FP), BX
	XCHGQ BX, (AX)
	XCHGQ BX, CX
	XCHGL BX, CX
	XCHGW BX, CX
	XCHGB BL, CL
	MOVQ  AX, ret+16(FP)
	RET

// func cmpxchg(p *uint64, old, new uint64) uint8
TEXT ·cmpxchg(SB), NOSPLIT, $0-25
	MOVQ     p+0(FP), AX
	MOVQ     old+8(FP), BX
	MOVQ     new+16(FP), CX
	CMPXCHGQ CX, (AX)
	CMPXCHGL CX, BX
	CMPXCHGW CX, BX
	CMPXCHGB CL, BL
	SETEQ    AL
	MOVB     AL, ret+24(FP)
	RET

// func xadd(p *uint64, v uint64) uint64
TEXT ·xadd(SB), NOSPLIT, $0-24
	MOVQ  p+0(FP), AX
	MOVQ  v+8(FP), BX
	XADDQ BX, (AX)
	XADDL BX, CX
	XADDW BX, CX
	XADDB BL, CL
	MOVQ  AX, ret+16(FP)
	RET

// func adcx_adox(lo, hi, x, y uint64) uint64
TEXT ·adcx_adox(SB), NOSPLIT, $0-40
	MOVQ  lo+0(FP), AX
	MOVQ  hi+8(FP), DX
	MOVQ  x+16(FP), BX
	MOVQ  y+24(FP), CX
	ADCXQ BX, AX
	ADOXQ CX, DX
	ADCXL BX, AX
	ADOXL CX, DX
	XORQ  BX, BX
	ADCXQ BX, AX
	MOVQ  AX, ret+32(FP)
	RET

// func crc32(crc uint32, p *byte, n int) uint32
TEXT ·crc32(SB), NOSPLIT, $0-28
	MOVL   crc+0(FP), AX
	MOVQ   p+8(FP), SI
	MOVQ   n+16(FP), CX
	CRC32B (SI), AX
	CRC32Q (SI), CX
	CRC32L (SI), AX
	MOVW   (SI), DX
	CRC32W DX, AX
	MOVL   AX, ret+24(FP)
	RET