Does AMOAND.B return the post-operation value?
No. Like A-extension AMOs, rd receives the old value loaded from memory.
AMOAND.B
RISC-V AMOAND.B Instruction Details
Instruction ManualAMO-typeAtomic byte AND: rd = *rs1 (sign-ext), *rs1 &= rs2[7:0]
Instruction Syntax
amoand.b rd, rs2, (rs1)
Operand Breakdown
rd: receives the old memory value read atomically; for AMOCAS, its pre-execution value also supplies the compare value.
rs1: directly supplies the atomic-memory address; AMO assembly syntax has no offset immediate field.
rs2: supplies the AMO source data; for AMOCAS, it is the swap value stored when the comparison matches.
AMO-type is this site's presentation label for the AMO-specific R-type field layout: funct5, aq, rl, rs2, rs1, funct3, rd, and the AMO opcode encode the operation.
ZabhaAtomic
Related Search Terms
Instruction Behavior
AMOAND.B is a Zabha instruction that depends on Zaamo. It atomically loads a byte from the address in rs1 into rd (sign-extended), ANDs with the low byte of rs2, and stores back. It supports aq/rl bits.
AMOAND.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
amoand.b,,()
Execution Context
31..27
26
25
24..20
19..15
14..12
11..7
6..0
01100
funct5
0
aq
0
rl
01011
rs2
01010
rs1
000
funct3
00101
rd
0101111
opcode
Atomic Data Path
instruction
0x60B502AF
opcode
0101111 -> AMO
funct3
000 -> byte width
funct5
01100 -> AMOAND.B
aq / rl
0/0 -> unordered
rd / rs2 / rs1
t0(x5) / a1(x11)=0x0F / a0(x10)=0x00001000
memory read
mem[0x00001000] -> old byte 0xF0
RMW
0xF0 & 0x0F -> 0x00
rd / memory
t0(x5) = 0xFFFFFFF0; mem[0x00001000] = 0x00
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: 0x60B502AF
syntax : amoand.b t0(x5), a1(x11), (a0(x10))
result : t0(x5) = 0xFFFFFFF0; mem[0x00001000] = 0x00
8-bit Byte Result View
7
6
5
4
3
2
1
0
1
1
1
1
0
0
0
0
old byte
0
0
0
0
1
1
1
1
rs2 byte
&
&
&
&
&
&
&
&
-
-
-
-
-
-
-
-
This animation shows ISA-visible atomic read-modify-write, compare-and-swap, LR/SC reservation state, and ordering bits, not any specific CPU cache-coherence implementation, pipeline, or timing.
Quick Understanding & Search Notes
AMOAND.B is a Zabha 8-bit atomic AND instruction. It atomically reads the old memory value, performs the read-modify-write at 8-bit width, 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, not the newly updated value.
The natural-alignment requirement for a byte operand is one byte, so every byte address is naturally aligned. aq/rl affects ordering, not the data result.
Common Usage Scenarios
Atomic & Sync
Understand this scenario with real code like «amoand.b a0, a2, (a1)».
Network & Byte Order
Understand this scenario with real code like «amoand.b a0, a2, (a1)».
Pre-Use Checklist
Syntax Check
- Confirm the current instruction format is AMO-type.
- Confirm the operand order matches the example.
Semantic Check
- Ensure the destination register usage is compatible with the calling convention.
- Confirm this is not the lower-level form of a pseudo-instruction expansion.
Pitfalls / Common Confusions
rd returns old memory value (sign-extended to XLEN), not the operation result
AMOAND.B applies bitwise AND only at 8-bit width between the old memory value and rs2[7:0], then writes the target byte.
The natural-alignment requirement for a byte operand is one byte, so every byte address is naturally aligned.
FAQ
Can AMOAND.B affect neighboring bytes?
Architecturally it modifies only the byte operand; Zabha provides native byte-granule atomic read-modify-write operations.