Struct Regs 

pub struct Regs {
    pub gpr: [u64; 32],
    pub hi: u64,
    pub lo: u64,
}

General-purpose registers plus the HI/LO multiply-divide pair.

Fields

gpr: [u64; 32]

32 general-purpose 64-bit registers. Index 0 is architecturally zero; prefer Regs::read / Regs::write over touching this directly.

hi: u64

HI — multiply high half, or division remainder.

lo: u64

LO — multiply low half, or division quotient.

Implementations

impl Regs

pub const fn new() -> Self

Power-on state: everything zero.

pub const fn read(&self, i: u8) -> u64

Read a general register. $zero always reads as 0.

The index is masked to 5 bits first, then the $zero rule is applied to the masked value. Checking before masking would let read(32) fall through to gpr[32 & 31] — gpr[0] — and leak it if it were ever corrupted. This is public API and cannot assume its caller pre-masked.

pub const fn write(&mut self, i: u8, v: u64)

Write a general register. A write to $zero is discarded, which is architectural, not a convenience: software relies on $zero staying zero after instructions that nominally target it.

Masked to 5 bits before the $zero check, for the same reason as Regs::read but with worse consequences: checking first would make write(32, v) land in gpr[0] and corrupt the architectural zero — in the one function whose entire purpose is preventing exactly that.

Trait Implementations

impl Clone for Regs

fn clone(&self) -> Regs

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Regs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Regs

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Regs

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Regs

fn eq(&self, other: &Regs) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Regs

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Regs

impl StructuralPartialEq for Regs