Struct FrameInsts 

pub struct FrameInsts {

    pub prefix: &'static str,
    pub classes: &'static [ClassMoves],
    pub push: &'static str,
    pub pop: &'static str,
    pub add: &'static str,
    pub sub: &'static str,
    pub align: &'static str,
    pub lea: &'static str,
    pub ret: &'static str,
    pub differ: &'static str,
    pub call: &'static str,
    pub probe: Option<Probe>,
    pub landing: Option<&'static str>,
}

Every instruction a prologue, an epilogue, a spill or a reload is made of.

Fields

prefix: &'static str

What a rule file and the machine IR put in front of this target’s opcodes, such as x64., which says which target a term belongs to and is not part of the opcode.

classes: &'static [ClassMoves]

How a register of each class is moved, one for each class of the register file in the order the file numbers them.

Shorter than the file when the classes at the end are ones nothing spills. An x87 stack register is one of those: the allocator is never given one to hand out, so nothing ever asks how to move it, and a target that answered anyway would be writing down a guess.

push: &'static str

Puts a register on the stack and moves the stack pointer down by one word.

pop: &'static str

Takes a word off the stack into a register and moves the stack pointer back up.

add: &'static str

Adds a constant to the stack pointer, which is how an epilogue gives the frame back.

sub: &'static str

Takes a constant off the stack pointer, which is how a prologue takes the frame.

align: &'static str

Clears the low bits of the stack pointer, which is how a prologue forces an alignment nothing else can give it.

lea: &'static str

Writes a register with an address rather than with what is at it, which is how an epilogue puts the stack pointer back when the frame pointer is the only record of where it was.

ret: &'static str

Returns to the caller.

differ: &'static str

Compares two general purpose registers and writes whether they differ into a third.

The stack protector’s check is the only thing that asks for this, and it is here rather than left to a lowering rule because no rule ever sees the comparison: the two words being compared are the canary the prologue wrote and the one the runtime still holds, and neither of them is a value the program named.

call: &'static str

Calls the name it is given and reads no register.

Here for the same reason, and used for the one call an epilogue can make, which is the one a changed canary makes.

probe: Option<Probe>

How a prologue touches a page of the stack, or None on a target where nothing can.

See Probe. It is an option rather than a name because a target that has no such instruction is a target where -fstack-clash-protection has to do nothing, and a name standing for nothing is worse than an absence a caller has to look at.

landing: Option<&'static str>

What says an indirect branch may arrive at an address, or None on a target where nothing does.

What -fcf-protection=branch asks for, and an option for the same reason Self::probe is: a target with no such instruction is one the flag cannot be honoured on, and the answer there is to say so rather than to write a name that stands for nothing. A prologue puts one at the top of every function, because a function’s own address is the one address of it a pointer can hold.

Implementations

impl FrameInsts

pub fn moves(&self, class: RegClass) -> Option<ClassMoves>

How a register of that class is moved, or None for a class nothing spills.

Trait Implementations

impl Clone for FrameInsts

fn clone(&self) -> FrameInsts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FrameInsts

impl Debug for FrameInsts

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

Formats the value using the given formatter.

impl Eq for FrameInsts

impl PartialEq for FrameInsts

fn eq(&self, other: &FrameInsts) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FrameInsts