Struct Calling 

pub struct Calling<'a> {
    pub callee: Callee,
    pub args: &'a [Passing],
    pub returns: &'a [Type],
    pub variadic: bool,
    pub named: usize,
}

One call, as everything about it that is not the function it is being built into.

Fields

callee: Callee

What it calls.

args: &'a [Passing]

What it passes, in the order the signature holds them, which is the order the convention places them in.

returns: &'a [Type]

What comes back, which is empty for a call that gives nothing back, one type for a value, and two for a structure small enough to come back in a pair of registers.

A pair is placed here rather than named by a rule for the reason the arguments are: which register each half goes in depends on the halves before it, since the two files are walked separately, and a pattern over a term cannot see them.

variadic: bool

Whether the callee takes arguments beyond the ones its signature names, which is what says whether it reads the count of vector registers the call passed arguments in.

named: usize

How many of the arguments the signature does name, so that the ones past it can be told apart from the ones before it.

A convention that passes a variadic float in both register files needs that, because which arguments get the second copy is exactly the ones the callee has no prototype for. Every other convention treats the two the same and never asks.

Trait Implementations

impl<'a> Clone for Calling<'a>

fn clone(&self) -> Calling<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Calling<'a>

impl<'a> Debug for Calling<'a>

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

Formats the value using the given formatter.