Struct regalloc::Writable

pub struct Writable<R: WritableBase> { /* private fields */ }

A “writable register”. This is a zero-cost wrapper that can be used to create a distinction, at the Rust type level, between a plain “register” and a “writable register”.

Only structs that implement the WritableBase trait can be wrapped with Writable. These are the Reg, RealReg and VirtualReg data structures only, since WritableBase is not exposed to end users.

Writable<..> can be used by the client to ensure that, internally, it only generates instructions that write to registers that should be written. The InstRegUses below, which must be implemented for every instruction, requires a Writable<Reg> (not just Reg) in its defined and modified sets. While we cannot hide the constructor for Writable<..> from certain parts of the client while exposing it to others, the client can adopt conventions to e.g. only ever call the Writable<..> constructor from its central vreg-management logic, and decide that any invocation of this constructor in a machine backend (for example) is an error.

Implementations

impl<R: WritableBase> Writable<R>

pub fn from_reg(reg: R) -> Writable<R>

Create a Writable from an R. The client should carefully audit where it calls this constructor to ensure correctness (see Writable<..> struct documentation).

pub fn to_reg(&self) -> R

Get the inner Reg.

pub fn map<F, U>(&self, f: F) -> Writable<U> where
    F: Fn(R) -> U,
    U: WritableBase, 

Trait Implementations

impl<R: Clone + WritableBase> Clone for Writable<R>

fn clone(&self) -> Writable<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + WritableBase> Debug for Writable<R>

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

Formats the value using the given formatter.

impl<R: Hash + WritableBase> Hash for Writable<R>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<R: Ord + WritableBase> Ord for Writable<R>

fn cmp(&self, other: &Writable<R>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<R: PartialEq + WritableBase> PartialEq<Writable<R>> for Writable<R>

fn eq(&self, other: &Writable<R>) -> bool

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

fn ne(&self, other: &Writable<R>) -> bool

This method tests for !=.

impl<R: PartialOrd + WritableBase> PartialOrd<Writable<R>> for Writable<R>

fn partial_cmp(&self, other: &Writable<R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<R: PrettyPrint + WritableBase> PrettyPrint for Writable<R>

fn show_rru(&self, maybe_reg_universe: Option<&RealRegUniverse>) -> String

Return a string that shows the implementing object in context of the given RealRegUniverse, if provided.

impl<R: PrettyPrintSized + WritableBase> PrettyPrintSized for Writable<R>

fn show_rru_sized(
    &self,
    maybe_reg_universe: Option<&RealRegUniverse>,
    size: u8
) -> String

The same as |show_rru|, but with an optional hint giving a size in bytes. Its interpretation is object-dependent, and it is intended to pass around enough information to facilitate printing sub-parts of real registers correctly. Objects may ignore size hints that are irrelevant to them.

impl<R: Copy + WritableBase> Copy for Writable<R>

impl<R: Eq + WritableBase> Eq for Writable<R>

impl<R: WritableBase> StructuralEq for Writable<R>

impl<R: WritableBase> StructuralPartialEq for Writable<R>