Information about stack frame layout on the target.
Synopsis
Declared in <llvm/CodeGen/TargetFrameLowering.h>
class TargetFrameLowering;Description
It holds the direction of stack growth, the known stack alignment on entry to each function, and the offset to the locals area.
The offset to the local area is the offset from the stack pointer on function entry to the first location where function data (local variables, spill locations) can be stored.
Types
Name |
Description |
Frame‐base location used when emitting DWARF unwind / debug info. |
|
Maps a callee‐saved register to a stack slot with a fixed offset. |
Enums
Name |
Description |
Direction in which the stack grows. |
Member Functions
Name |
Description |
|
Construct target frame‐lowering information. |
|
Destroy the target frame‐lowering object. |
|
Adjust the prologue to add Erlang Run‐Time System (ERTS) specific code in the assembly prologue to explicitly handle the stack. |
|
Adjust the prologue to have the function use segmented stacks. This works by adding a check even before the "normal" function prologue. |
alignSPAdjust ‐ This method aligns the stack adjustment to the correct alignment. |
|
Control the placement of special register scavenging spill slots when allocating a stack frame. |
|
|
Allow the target to override callee‐saved spill slot assignment. |
|
Return true if call‐frame pseudos can be simplified before FI elimination. |
|
Check whether |
|
Check whether |
|
Determine which callee‐saved registers should actually be saved. |
Determine registers that must be saved/restored in the prolog/epilog. |
|
|
Eliminate call‐frame setup/destroy pseudo instructions. |
|
With basic block sections, emit callee saved frame moves for basic blocks that are in a different section. |
|
Insert epilogue code into the function. |
|
Insert prologue code into the function. |
|
This method is called at the end of prolog/epilog code insertion, so targets can emit remarks based on the final frame layout. |
|
emitZeroCallUsedRegs ‐ Zeros out call used registers. |
|
Returns true if we may need to fix the unwind information for the function. |
|
Returns true if the target can safely skip saving callee‐saved registers for noreturn nounwind functions. |
|
Return true if unwind info may need to be accurate for every instruction. |
|
Returns true if the target will correctly handle shrink wrapping. |
|
Returns true if the stack slot holes in the fixed and callee‐save stack area should be used when allocating other stack locations to reduce stack size. |
|
Return fixed spill slots for callee‐saved registers that need them. |
|
Returns the callee‐saved registers as computed by determineCalleeSaves in the BitVector |
|
Return the frame base information to be encoded in the DWARF subprogram debug info. |
|
Return the base register and offset used to reference a frame index. |
|
Return the offset from SP at function entry to the given frame index. |
|
Prefer SP when returning the base register for a frame‐index reference. |
|
Return initial CFA offset value i.e. the one valid at the beginning of the function (before any stack operations). |
|
Return initial CFA register value i.e. the one valid at the beginning of the function (before any stack operations). |
Return registers that must be preserved across the function. |
|
|
Return the offset used to reference a non‐local frame index. |
getOffsetOfLocalArea ‐ This method returns the offset of the local area from the stack pointer on entrance to a function. |
|
Return the stack alignment required on function entry. |
|
Return how many bytes the stack pointer must be aligned to on entry. |
|
getStackGrowthDirection ‐ Return the direction the stack grows |
|
|
Returns the StackID that scalable vectors should be associated with. |
|
getStackThreshold ‐ Return the maximum stack size |
getTransientStackAlignment ‐ This method returns the number of bytes to which the stack pointer must be aligned at all times, even between calls. |
|
|
Return the Windows EH parent‐frame offset for this function. |
Return true if the function should have a dedicated frame pointer. |
|
|
Return true if the call frame is included as part of the stack frame. |
|
Replace a StackProbe stub (if any) with the actual probe code inline |
|
Check if the no‐CSR optimisation is profitable for the given function. |
|
This method returns whether or not it is safe for an object with the given stack id to be bundled into the local area. |
isStackRealignable ‐ This method returns whether the stack can be realigned. |
|
|
Return true if the target supports allocating objects with stack ID |
|
Return whether frame‐index operands need resolution for this function. |
|
Order the symbols in the local stack frame. |
|
Hook called immediately before the function's frame layout is finalized. |
Hook called after frame finalization but before FI operands are replaced. |
|
|
Emit CFI instructions that recreate the state of the unwind information upon function entry. |
Restore a single callee‐saved register. |
|
|
Restore all callee‐saved registers, or report that per‐register loads should be used instead. |
spillCalleeSavedRegister ‐ Default implementation for spilling a single callee saved register. |
|
|
Spill all callee‐saved registers, or report that per‐register stores should be used instead. |
|
If frame pointer or base pointer is clobbered by an instruction, we should spill/restore it around that instruction. |
|
Does the stack probe function call return with a modified stack pointer? |
|
targetHandlesStackFrameRounding ‐ Returns true if the target is responsible for rounding up the stack frame (probably at emitPrologue time). |
Static Member Functions
Name |
Description |
Check if given function is safe for not having callee saved registers. This is used when interprocedural register allocation is enabled. |