Struct Vtype 

pub struct Vtype<Hart>
where
    Hart: VectorHartConfig,
{ /* private fields */ }

Decoded vtype register contents.

The vtype CSR controls the interpretation of the vector register file: element width, register grouping, and tail/mask agnostic policies.

The raw encoding is XLEN-dependent (vill is at bit XLEN-1), but this decoded form is XLEN-independent.

Implementations

impl<Hart> Vtype<Hart>

where Hart: VectorHartConfig,

pub const fn vma(&self) -> bool

Vector mask agnostic policy (bit 7)

pub const fn vta(&self) -> bool

Vector tail agnostic policy (bit 6)

pub const fn vsew(&self) -> Vsew

Selected element width (bits [5:3])

pub const fn vlmul(&self) -> Vlmul

Vector length multiplier (bits [2:0])

pub const fn eew_register_count(&self, eew: Eew) -> Option<VRegGroupSize>

Number of registers in a group of elements with effective element width eew, where EMUL = (EEW / SEW) * LMUL.

Returns None when EEW exceeds ELEN or EMUL falls outside the legal range [1/8, 8], both of which are reserved.

pub const fn vlmax(&self) -> Vl

VLMAX = LMUL * VLEN / SEW, which is at least 1 for any valid vtype

pub const fn from_raw<Reg>(raw: Reg::Type) -> Option<Self>

where Reg: Register,

Decode from raw register value.

The XLEN is taken from Reg::XLEN and must be 32 for RV32 or 64 for RV64. The vill bit is placed at bit position Reg::XLEN - 1.

All bits in [Reg::XLEN-1:8] must be zero; non-zero bits indicate an unrecognized encoding and cause None to be returned (this includes vill).

pub const fn to_raw<Reg>(self) -> Reg::Type

where Reg: Register,

Encode to a raw vtype register value of type Reg::Type.

The encoded value contains vlmul, vsew, vta, and vma in bits [7:0] with vill = 0. To construct a raw value with vill = 1 (illegal configuration), use Self::illegal_raw.

pub const fn illegal_raw<Reg>() -> Reg::Type

where Reg: Register,

Construct a raw value for vtype with vill=1 (illegal configuration).

Per spec: when vill is set, the remaining bits are zero and vl is also set to zero. Any subsequent vector instruction that depends on vtype will raise an illegal-instruction exception.

Trait Implementations

impl<Hart> Clone for Vtype<Hart>

where Hart: VectorHartConfig + Clone,

fn clone(&self) -> Vtype<Hart>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Hart> Copy for Vtype<Hart>

where Hart: VectorHartConfig + Copy,

impl<Hart> Debug for Vtype<Hart>

where Hart: VectorHartConfig + Debug,

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

Formats the value using the given formatter.

impl<Hart> Eq for Vtype<Hart>

where Hart: VectorHartConfig,

impl<Hart> PartialEq for Vtype<Hart>

where Hart: VectorHartConfig,

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

Equality operator ==.

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

Inequality operator !=.