Does AMOMAXU.B return the post-operation value?
No. Like A-extension AMOs, rd receives the old value loaded from memory.
AMOMAXU.B
RISC-V AMOMAXU.B Instruction Details
Instruction ManualAMO-typeAtomic byte unsigned max: rd = *rs1 (sign-ext), *rs1 = umax(*rs1, rs2[7:0])
Instruction Syntax
amomaxu.b rd, rs2, (rs1)
Syntax is rd, rs2, (rs1). The three fields select x0–x31 or ABI names, with no offset immediate or rs3.
funct5=11100, funct3=000, opcode=0101111; aq at bit26 and rl at bit25 are independent ordering bits.
RV32/RV64 Zabha (requires Zaamo): rd receives the sign-extended old 8-bit memory value; only the low 8 rs2 bits compute new memory.
The region must support this AMO width and operation. Every byte address is naturally aligned.
Sources use pre-execution values; rd=x0 discards register writeback while memory read-modify-write still occurs. aq/rl orders only the accessed memory/I/O domain.
ZabhaAtomic
Instruction Behavior
AMOMAXU.B is a Zabha instruction, for which Zabha depends on Zaamo. It atomically loads a byte from the address in rs1 into rd (sign-extended), compares it as an unsigned byte with the low byte of rs2, stores the selected unsigned max value back, and supports aq/rl bits.
AMOMAXU.B Atomic Decode And Execute Animation
Shows Zabha (requires Zaamo) byte atomic field decode, aq/rl ordering bits, a memory read, and RMW state update.
rd
rs2
rs1
amomaxu.b,,()
Execution Context
31..27
26
25
24..20
19..15
14..12
11..7
6..0
11100
funct5
0
aq
0
rl
01011
rs2
01010
rs1
000
funct3
00101
rd
0101111
opcode
Atomic Data Path
instruction
0xE0B502AF
opcode
0101111 -> AMO
funct3
000 -> byte width
funct5
11100 -> AMOMAXU.B
aq / rl
0/0 -> unordered
rd / rs2 / rs1
t0(x5) / a1(x11)[7:0]=0x01 / a0(x10)=0x00001000
memory read
mem[0x00001000] -> old byte 0x80
RMW
Not computed
rd / memory
t0(x5) = unspecified initial value; mem[0x00001000] = 0x80
Current Step
Concept Step: receive the 32-bit atomic instruction encoding
Zabha depends on Zaamo; Zabha-extension byte atomic instructions use a 32-bit encoding; the animation starts by splitting the fields.
encoding: 0xE0B502AF
syntax : amomaxu.b t0(x5), a1(x11), (a0(x10))
Pending result : Not computed
Current architectural state
t0(x5) = unspecified initial value; mem[0x00001000] = 0x80
Assumes Zabha and Zaamo at the selected XLEN, successful fetch, a region supporting this width and operation, and a successful access. A misaligned halfword requires the stated PMA condition. Sources use pre-execution values; aq/rl orders only the accessed domain. Steps are a teaching sequence.
Quick Understanding & Search Notes
AMOMAXU.B is a Zabha 8-bit unsigned max instruction. It atomically reads the old memory value, selects the memory writeback with an unsigned 8-bit comparison, and writes the sign-extended old value to rd.
Only the 8-bit subword is operated on; upper bits of rs2 are ignored.
rd receives the old memory value sign-extended to XLEN; unsigned affects the min/max comparison, not rd extension.
A byte operand has one-byte natural alignment; aq/rl bits can provide release-consistency ordering semantics.
Common Usage Scenarios
Atomic & Sync
RV32/RV64 Zabha+Zaamo, a1=0x1000, old 8-bit memory=0x80 and a2=1; assume a supporting region and normal completion: amomaxu.b a0, a2, (a1) returns a0=0xFFFFFF80 (RV32) or 0xFFFFFFFFFFFFFF80 (RV64) and writes 0x80 to memory. Comparison uses unsigned 8-bit values.
Pre-Use Checklist
Syntax Check
- Syntax is rd, rs2, (rs1). The three fields select x0–x31 or ABI names, with no offset immediate or rs3.
- funct5=11100, funct3=000, opcode=0101111; aq at bit26 and rl at bit25 are independent ordering bits.
Semantic Check
- RV32/RV64 Zabha (requires Zaamo): rd receives the sign-extended old 8-bit memory value; only the low 8 rs2 bits compute new memory.
- The region must support this AMO width and operation. Every byte address is naturally aligned.
- Sources use pre-execution values; rd=x0 discards register writeback while memory read-modify-write still occurs. aq/rl orders only the accessed memory/I/O domain.
Pitfalls / Common Confusions
rd returns the old memory value (sign-extended to XLEN), not the operation result
Unsigned maximum comparison; negative values become very large when interpreted as unsigned
Zabha supplies the byte AMO; byte addresses are naturally aligned to the one-byte operand size
FAQ
Can AMOMAXU.B affect neighboring bytes?
Architecturally it modifies only the byte operand; Zabha provides native byte-granule atomic read-modify-write operations.