CBO.ZERO

RISC-V CBO.ZERO Instruction Details

Instruction ManualCBO MISC-MEM fixed fields

cache-block zero (Zicboz).

Instruction Syntax

cbo.zero offset(base)

base selects integer x0–x31; x0 gives address 0. Any explicit offset must be 0 and may be omitted; no destination register is written.

32-bit MISC-MEM: operation=000000000100, rs1=base, funct3=010, rd=00000, opcode=0001111.

RV32/RV64 Zicboz; CBZE and privilege/virtualization state control execution. Illegal, virtual, or store-class access/page/guest-page faults are possible. CMOs have no address-misaligned exception.

Store zero to all corresponding bytes; whole-block atomicity is not guaranteed. Translation selects a physical cache block; the environment supplies its size. Zero stores obey store-ordering rules.

ZicbozCache & Sync

Related Search Terms

cbo.zero instruction RISC-V cbo.zero cbo.zero syntax cbo.zero encoding cbo.zero cache-block zero cbo.zero CMO cbo.zero cache block

Instruction Behavior

CBO.ZERO is a Zicboz cache-block zero instruction that performs stores of zero to all bytes corresponding to the cache block containing the address in rs1. rs1 need not be aligned to the cache-block size; an implementation may update bytes in any order, granularity, and atomicity, and whole-block atomicity is not guaranteed. The cache-block size is discovered from the execution environment and is not fixed at 64 bytes; the offset may be omitted, and if present must be 0.

CBO.ZERO Decode And Cache-Block Animation

Shows the official CMO/prefetch encoding, offset(base) operands, effective-address-to-cache-block selection, and ISA-visible effects.

offset

base

cbo.zero

(

)

Execution ContextXLENbase address valuecache-block sizeenvironment permission

31..20

19..15

14..12

11..7

6..0

000000000100

cbo op

01011

rs1

010

funct3=CBO

00000

rd=x0

0001111

MISC-MEM

Cache-Block Data Path

instruction

0x0045A00F

opcode

0001111 -> MISC-MEM

operation

000000000100 -> CBO.ZERO

funct3

010 -> CBO

offset/base

0(x11)

effective addr

0x0000000000001018 + 0x0000000000000000 = 0x0000000000001018

cache block

0x0000000000001000..0x000000000000103F

operation

store zero to bytes corresponding to the target cache block; whole-block atomicity is not guaranteed

complete

cache-block management semantics complete

Current Step

Receive the 32-bit CBO.ZERO encoding

CBO.ZERO uses a 32-bit encoding; the animation starts by splitting the official fields.

encoding: 0x0045A00F

syntax : cbo.zero 0(x11)

effect : store zero to bytes corresponding to the target cache block; whole-block atomicity is not guaranteed

Cache-Block Selection View

base

0x0000000000001018

target block

0x0000000000001000..0x000000000000103F

The example cache-block size is 64 bytes only to show how the address selects a block; the real size is discovered from the execution environment and is not fixed at 64 bytes. This demonstration assumes identical virtual and physical addresses for the selected block; base x0 gives address 0.

This animation shows only architectural semantics from the RISC-V CMO extension: the effective address is translated before a cache block is selected, CBO execution can be environment-controlled, and prefetch is an ignorable HINT; it does not model concrete cache state, physical mappings, cache-line size, bus transactions, timing, or performance.

Quick Understanding & Search Notes

CBO.ZERO stores zero to every byte corresponding to the target cache block; it does not perform clean or invalidate.

For cbo.*, any explicit offset must be zero and the target is the cache block containing rs1.

CBO.ZERO may write zeros at implementation-chosen granularity and does not guarantee atomic whole-block update.

The RISC-V Instruction Set Manual, Volume I: Unprivileged Architecture The RISC-V Instruction Set Manual, Volume II: Privileged Architecture

Common Usage Scenarios

Zero bytes corresponding to a cache block

cbo.zero 0(a1). Initialize the example source and enable the required extensions and state. Assume permitted access, identical virtual/physical addresses, and 64-byte cache blocks.

Pre-Use Checklist

Syntax Check

base selects integer x0–x31; x0 gives address 0. Any explicit offset must be 0 and may be omitted; no destination register is written.
32-bit MISC-MEM: operation=000000000100, rs1=base, funct3=010, rd=00000, opcode=0001111.

Semantic Check

RV32/RV64 Zicboz; CBZE and privilege/virtualization state control execution. Illegal, virtual, or store-class access/page/guest-page faults are possible. CMOs have no address-misaligned exception.
Store zero to all corresponding bytes; whole-block atomicity is not guaranteed. Translation selects a physical cache block; the environment supplies its size. Zero stores obey store-ordering rules.

Pitfalls / Common Confusions

The assembly offset operand may be omitted; if present, it must evaluate to zero.

rs1 need not be aligned to cache-block size; fault reporting uses the rs1 virtual address.

Execution permission is controlled by xenvcfg-related fields and privilege/virtualization state.

FAQ

Is CBO.ZERO equivalent to a fence?

No. It produces zero stores governed by store-ordering rules; it is not itself a memory fence.

Must the address for CBO.ZERO be cache-block aligned?

CBO instructions do not require rs1 to be aligned to cache-block size.