Struct cranelift_codegen::machinst::abi_impl::ABICallerImpl

pub struct ABICallerImpl<M: ABIMachineSpec> { /* fields omitted */ }

ABI object for a callsite.

Implementations

impl<M: ABIMachineSpec> ABICallerImpl<M>

pub fn from_func(
    sig: &Signature,
    extname: &ExternalName,
    dist: RelocDistance,
    caller_conv: CallConv,
    flags: &Flags
) -> CodegenResult<ABICallerImpl<M>>

Create a callsite ABI object for a call directly to the specified function.

pub fn from_ptr(
    sig: &Signature,
    ptr: Reg,
    opcode: Opcode,
    caller_conv: CallConv,
    flags: &Flags
) -> CodegenResult<ABICallerImpl<M>>

Create a callsite ABI object for a call to a function pointer with the given signature.

Trait Implementations

impl<M: ABIMachineSpec> ABICaller for ABICallerImpl<M>

type I = M::I

The instruction type for the ISA associated with this ABI.

fn signature(&self) -> &Signature

Access the (possibly legalized) signature.

fn num_args(&self) -> usize

Get the number of arguments expected.

fn accumulate_outgoing_args_size<C: LowerCtx<I = Self::I>>(&self, ctx: &mut C)

Accumulate outgoing arguments. This ensures that the caller (as identified via the CTX argument) allocates enough space in the prologue to hold all arguments and return values for this call. There is no code emitted at the call site, everything is done in the caller’s function prologue.

fn emit_stack_pre_adjust<C: LowerCtx<I = Self::I>>(&self, ctx: &mut C)

Emit code to pre-adjust the stack, prior to argument copies and call.

fn emit_stack_post_adjust<C: LowerCtx<I = Self::I>>(&self, ctx: &mut C)

Emit code to post-adjust the satck, after call return and return-value copies.

fn emit_copy_regs_to_arg<C: LowerCtx<I = Self::I>>(
    &self,
    ctx: &mut C,
    idx: usize,
    from_regs: ValueRegs<Reg>
)

Emit a copy of an argument value from a source register, prior to the call.

fn get_copy_to_arg_order(&self) -> SmallVec<[usize; 8]>

Specific order for copying into arguments at callsites. We must be careful to copy into StructArgs first, because we need to be able to invoke memcpy() before we’ve loaded other arg regs (see above).

fn emit_copy_retval_to_regs<C: LowerCtx<I = Self::I>>(
    &self,
    ctx: &mut C,
    idx: usize,
    into_regs: ValueRegs<Writable<Reg>>
)

Emit a copy a return value into a destination register, after the call returns.

fn emit_call<C: LowerCtx<I = Self::I>>(&mut self, ctx: &mut C)

Emit the call itself.