Enum PassMode 

pub enum PassMode {
    Ignore,
    Direct(ArgAttributes),
    Pair(ArgAttributes, ArgAttributes),
    Cast {
        pad_i32_count: u8,
        cast: CastTarget,
    },
    Indirect {
        attrs: ArgAttributes,
        meta_attrs: Option<ArgAttributes>,
        on_stack: bool,
    },
}

How a function argument should be passed in to the target function.

The pass mode is determined by the platform’s calling convention and the argument’s type layout. The same Rust type may use different pass modes on different targets or when register availability changes.

Note: for the Rust ABI, pass modes may not correspond to any valid C calling convention (e.g., using more return registers than the platform C ABI allows). Further processing may be needed depending on the target.

Variants

Ignore

Ignore the argument.

The argument is either uninhabited or a ZST (zero-sized type).

Direct(ArgAttributes)

Pass the argument directly in a single register.

Used for primitive types and small values that fit in one register.

Pair(ArgAttributes, ArgAttributes)

Pass the argument directly in two registers.

Used for types represented as a pair of values (e.g., a fat pointer consisting of a data pointer and a length/vtable pointer).

Cast

Pass the argument after reinterpreting it as a different register layout.

Used for aggregates (structs, tuples) that the platform ABI passes in registers. The argument’s bytes are reinterpreted as the register sequence described by CastTarget. See its documentation for details.

Fields

pad_i32_count: u8

cast: CastTarget

Indirect

Pass the argument indirectly via a pointer.

The caller places the value in memory and passes a pointer to it. When on_stack is true, the value is placed at a fixed stack offset rather than passed as a regular pointer argument.

Fields

attrs: ArgAttributes

meta_attrs: Option<ArgAttributes>

Attributes for the metadata pointer (vtable or length) of unsized arguments. Only present for unsized types (e.g., dyn Trait, [T]).

on_stack: bool

Trait Implementations

impl Clone for PassMode

fn clone(&self) -> PassMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PassMode

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

Formats the value using the given formatter.

impl Eq for PassMode

impl Hash for PassMode

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 PassMode

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for PassMode

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 PassMode

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: 80 bytes

Size for each variant:

• Ignore: 0 bytes
• Direct: 40 bytes
• Pair: 72 bytes
• Cast: 80 bytes
• Indirect: 80 bytes