Enum rustc_codegen_llvm::abi::PassMode

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

Variants

Ignore

Ignore the argument.

The argument is either uninhabited or a ZST.

Direct(ArgAttributes)

Pass the argument directly.

The argument has a layout abi of Scalar or Vector. Unfortunately due to past mistakes, in rare cases on wasm, it can also be Aggregate. This is bad since it leaks LLVM implementation details into the ABI. (Also see https://github.com/rust-lang/rust/issues/115666.)

Pair(ArgAttributes, ArgAttributes)

Pass a pair’s elements directly in two arguments.

The argument has a layout abi of ScalarPair.

Cast

Pass the argument after casting it. See the CastTarget docs for details.

pad_i32 indicates if a Reg::i32() dummy argument is emitted before the real argument.

Fields

pad_i32: bool

cast: Box<CastTarget>

Indirect

Pass the argument indirectly via a hidden pointer.

The meta_attrs value, if any, is for the metadata (vtable or length) of an unsized argument. (This is the only mode that supports unsized arguments.)

on_stack defines that the value should be passed at a fixed stack offset in accordance to the ABI rather than passed using a pointer. This corresponds to the byval LLVM argument attribute. The byval argument will use a byte array with the same size as the Rust type (which ensures that padding is preserved and that we do not rely on LLVM’s struct layout), and will use the alignment specified in attrs.pointee_align (if Some) or the type’s alignment (if None). This means that the alignment will not always match the Rust type’s alignment; see documentation of make_indirect_byval for more info.

on_stack cannot be true for unsized arguments, i.e., when meta_attrs is Some.

Fields

attrs: ArgAttributes

meta_attrs: Option<ArgAttributes>

on_stack: bool

Implementations

impl PassMode

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

Checks if these two PassMode are equal enough to be considered “the same for all function call ABIs”. However, the Layout can also impact ABI decisions, so that needs to be compared as well!

Trait Implementations

impl Clone for PassMode

fn clone(&self) -> PassMode

Returns a copy 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<(), Error>

Formats the value using the given formatter.

impl Hash for PassMode

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

where __H: Hasher,

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<__CTX> HashStable<__CTX> for PassMode

where __CTX: HashStableContext,

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl PartialEq for PassMode

fn eq(&self, other: &PassMode) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for PassMode

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

Size for each variant:

• Ignore: 0 bytes
• Direct: 23 bytes
• Pair: 39 bytes
• Cast: 15 bytes
• Indirect: 39 bytes