Struct FnAbi

pub(crate) struct FnAbi<'a, Ty> {
    pub args: Box<[ArgAbi<'a, Ty>]>,
    pub ret: ArgAbi<'a, Ty>,
    pub c_variadic: bool,
    pub fixed_count: u32,
    pub conv: Conv,
    pub can_unwind: bool,
}

Metadata describing how the arguments to a native function should be passed in order to respect the native ABI.

The signature represented by this type may not match the MIR function signature. Certain attributes, like #[track_caller] can introduce additional arguments, which are present in FnAbi, but not in FnSig. While this difference is rarely relevant, it should still be kept in mind.

I will do my best to describe this structure, but these comments are reverse-engineered and may be inaccurate. -NDM

Fields

args: Box<[ArgAbi<'a, Ty>]>

The type, layout, and information about how each argument is passed.

ret: ArgAbi<'a, Ty>

The layout, type, and the way a value is returned from this function.

c_variadic: bool

Marks this function as variadic (accepting a variable number of arguments).

fixed_count: u32

The count of non-variadic arguments.

Should only be different from args.len() when c_variadic is true. This can be used to know whether an argument is variadic or not.

conv: Conv

The calling convention of this function.

can_unwind: bool

Indicates if an unwind may happen across a call to this function.

Implementations

impl<'a, Ty> FnAbi<'a, Ty>

pub fn adjust_for_foreign_abi<C>( &mut self, cx: &C, abi: ExternAbi, ) -> Result<(), AdjustForForeignAbiError>

where Ty: TyAbiInterface<'a, C> + Copy, C: HasDataLayout + HasTargetSpec + HasWasmCAbiOpt + HasX86AbiOpt,

pub fn adjust_for_rust_abi<C>(&mut self, cx: &C, abi: ExternAbi)

where Ty: TyAbiInterface<'a, C> + Copy, C: HasDataLayout + HasTargetSpec,

Trait Implementations

impl<'tcx> ArenaAllocatable<'tcx> for FnAbi<'tcx, Ty<'tcx>>

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut FnAbi<'tcx, Ty<'tcx>>

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = FnAbi<'tcx, Ty<'tcx>>>, ) -> &'tcx mut [FnAbi<'tcx, Ty<'tcx>>]

impl<'a, Ty> Clone for FnAbi<'a, Ty>

where Ty: Clone,

fn clone(&self) -> FnAbi<'a, Ty>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, Ty> Debug for FnAbi<'a, Ty>

where Ty: Display,

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

Formats the value using the given formatter.

impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>>

fn llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type

fn ptr_to_llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type

fn llvm_cconv(&self) -> CallConv

fn apply_attrs_llfn( &self, cx: &CodegenCx<'ll, 'tcx>, llfn: &'ll Value, instance: Option<Instance<'tcx>>, )

Apply attributes to a function declaration/definition.

fn apply_attrs_callsite( &self, bx: &mut Builder<'_, 'll, 'tcx>, callsite: &'ll Value, )

Apply attributes to a function call.

impl<'a, Ty> Hash for FnAbi<'a, Ty>

where Ty: Hash,

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<'a, Ty, __CTX> HashStable<__CTX> for FnAbi<'a, Ty>

where __CTX: HashStableContext, Ty: HashStable<__CTX>,

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

impl<'a, Ty> PartialEq for FnAbi<'a, Ty>

where Ty: PartialEq,

fn eq(&self, other: &FnAbi<'a, Ty>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, Ty> Eq for FnAbi<'a, Ty>

where Ty: Eq,

impl<'a, Ty> StructuralPartialEq for FnAbi<'a, Ty>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.