Struct cranelift_codegen::isa::registers::RegClassData

pub struct RegClassData {
    pub name: &'static str,
    pub index: u8,
    pub width: u8,
    pub bank: u8,
    pub toprc: u8,
    pub first: RegUnit,
    pub subclasses: RegClassMask,
    pub mask: RegUnitMask,
    pub info: &'static RegInfo,
    pub pinned_reg: Option<RegUnit>,
}

Data about a register class.

A register class represents a subset of the registers in a bank. It describes the set of permitted registers for a register operand in a given encoding of an instruction.

A register class can be a subset of another register class. The top-level register classes are disjoint.

Fields

name: &'static str

The name of the register class.

index: u8

The index of this class in the ISA’s RegInfo description.

width: u8

How many register units to allocate per register.

bank: u8

Index of the register bank this class belongs to.

toprc: u8

Index of the top-level register class contains this one.

first: RegUnit

The first register unit in this class.

subclasses: RegClassMask

Bit-mask of sub-classes of this register class, including itself.

Bits correspond to RC indexes.

mask: RegUnitMask

Mask of register units in the class. If width > 1, the mask only has a bit set for the first register unit in each allocatable register.

info: &'static RegInfo

The global RegInfo instance containing this register class.

pinned_reg: Option<RegUnit>

The “pinned” register of the associated register bank.

This register must be non-volatile (callee-preserved) and must not be the fixed output register of any instruction.

Implementations

impl RegClassData

pub fn intersect_index(&self, other: RegClass) -> Option<RegClassIndex>

Get the register class index corresponding to the intersection of self and other.

This register class is guaranteed to exist if the register classes overlap. If the register classes don’t overlap, returns None.

pub fn intersect(&self, other: RegClass) -> Option<RegClass>

Get the intersection of self and other.

pub fn has_subclass<RCI: Into<RegClassIndex>>(&self, other: RCI) -> bool

Returns true if other is a subclass of this register class. A register class is considered to be a subclass of itself.

pub fn toprc(&self) -> RegClass

Get the top-level register class containing this class.

pub fn unit(&self, offset: usize) -> RegUnit

Get a specific register unit in this class.

pub fn contains(&self, regunit: RegUnit) -> bool

Does this register class contain regunit?

pub fn is_pinned_reg(&self, enabled: bool, regunit: RegUnit) -> bool

If the pinned register is used, is the given regunit the pinned register of this class?

pub fn index_of(&self, regunit: RegUnit) -> u16

Calculate the index of the register inside the class.

Trait Implementations

impl Debug for RegClassData

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

Formats the value using the given formatter.

impl Display for RegClassData

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

Formats the value using the given formatter.

impl From<&'static RegClassData> for RegClassIndex

fn from(rc: RegClass) -> Self

Performs the conversion.

impl PartialEq<RegClassData> for RegClassData

Within an ISA, register classes are uniquely identified by their index.

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.