Struct Latch 

pub struct Latch {
    pub occupied: bool,
    pub pc: u64,
    pub word: u32,
    pub in_delay_slot: bool,
    pub abort: Option<Exception>,
    pub decoded: Decoded,
    pub rs_val: u64,
    pub rt_val: u64,
    pub write_back: WriteBack,
    pub mem: Option<MemOp>,
    pub cop0: Option<Cop0Access>,
}

State carried across one inter-stage boundary — what travels with an instruction as it advances.

Fields

occupied: bool

Is an instruction present at this boundary? A bubble is false.

pc: u64

The PC of the instruction in flight.

word: u32

The raw instruction word (decode is T-11-002).

in_delay_slot: bool

Is this instruction in a branch delay slot?

Travels with the instruction, never as global CPU state — that is the whole point (see the module docs).

abort: Option<Exception>

An aborting condition stamped into this latch and every latch upstream.

decoded: Decoded

The decoded instruction, filled at IC.

rs_val: u64

rs value, read at RF.

rt_val: u64

rt value, read at RF.

write_back: WriteBack

What EX computed, committed at WB.

mem: Option<MemOp>

A memory access EX resolved for DC to perform.

cop0: Option<Cop0Access>

A COP0 access EX resolved: read performed in DC, write in WB.

Split across those two stages because UM §4.6.9 defines the CP0 bypass interlock in terms of a write reaching WB while the next instruction reads in DC — a rule that cannot be expressed if both happen in EX.

Trait Implementations

impl Clone for Latch

fn clone(&self) -> Latch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Latch

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

Formats the value using the given formatter.

impl Default for Latch

fn default() -> Latch

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Latch

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Latch

fn eq(&self, other: &Latch) -> 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 Latch

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Latch

impl Eq for Latch

impl StructuralPartialEq for Latch