Struct Layout 

pub struct Layout<'a> {
    pub conv: &'a CallRegs,
    pub file: RegFile,
    pub locals: &'a [Local],
    pub outgoing: u32,
    pub leaf: bool,
    pub frame_pointer: bool,
    pub grows: bool,
    pub red_zone: bool,
    pub protect: bool,
}

Everything about a function’s frame that does not come out of its allocation.

Fields

conv: &'a CallRegs

Where the convention this function is compiled for puts things.

file: RegFile

The registers the target has, which is what says how wide a spill slot of a class is.

locals: &'a [Local]

The memory the function asked for itself, in the order it wants it reported back.

outgoing: u32

How many bytes the widest call in the function needs for arguments it passes on the stack.

leaf: bool

Whether the function calls nothing, which is what the alignment and the red zone turn on.

frame_pointer: bool

Whether the function keeps a frame pointer, which -fno-omit-frame-pointer asks for and which a realigned or a dynamically grown frame requires whatever the flags say.

grows: bool

Whether the function moves the stack pointer while it runs, which is what a variable length array does and what the rest of the frame then has to be reached around.

See Growing in the module documentation. A frame like this keeps a frame pointer, takes its bytes rather than living in the red zone, and reports every offset in its body from the frame pointer, because the stack pointer stops being somewhere a constant reaches from.

red_zone: bool

Whether the red zone may be used at all, which -mno-red-zone and every kernel turns off.

protect: bool

Whether the frame holds a stack protector’s canary, which -fstack-protector and the function’s own attribute decide between them.

A protected frame is never a leaf, whatever the function called, because the check at the end of it calls when it fails. The caller sets leaf accordingly rather than this working it out, so that there is one place a frame learns whether it owes an aligned stack pointer.

Implementations

impl<'a> Layout<'a>

pub fn new(conv: &'a CallRegs, file: RegFile) -> Self

A layout for a function with nothing in it but what its allocation says: a leaf with no locals and no calls, which is what every function is until the pieces that produce those exist.

Trait Implementations

impl<'a> Clone for Layout<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Layout<'a>

impl<'a> Debug for Layout<'a>

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

Formats the value using the given formatter.