Struct Uniform 

pub struct Uniform {
    pub unit: Reg,
    pub total: MachineSize,
    pub is_consecutive: bool,
}

A sequence of registers of the same kind used to pass an argument.

Fields

unit: Reg

The type of register used.

total: MachineSize

The total size of the argument, which can be:

• equal to unit.size (one scalar/vector),
• a multiple of unit.size (an array of scalar/vectors),
• if unit.kind is Integer, the last element can be shorter, i.e., { i64, i64, i32 } for 64-bit integers with a total size of 20 bytes. When the argument is actually passed, this size will be rounded up to the nearest multiple of unit.size.

is_consecutive: bool

Whether the argument is consecutive: either all values are passed in registers, or all on the stack with no additional padding between elements.

Implementations

impl Uniform

pub fn reg_count(&self) -> usize

Return the number of registers needed to cover total.

Trait Implementations

impl Clone for Uniform

fn clone(&self) -> Uniform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Uniform

impl Debug for Uniform

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

Formats the value using the given formatter.

impl Eq for Uniform

impl Hash for Uniform

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Uniform

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Uniform

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Uniform

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes