AsmJit
Low-Latency Machine Code Generation
Roadmap
Docs
Parser
Support
GitHub
Index ⭢ Function ⭢ asmjit::FuncFrame

asmjit::FuncFrame Class Reference [¶]

Function frame.

Function frame is used directly by prolog and epilog insertion (PEI) utils. It provides information necessary to insert a proper and ABI conforming prolog and epilog. Function frame calculation is based on CallConv and other function attributes.

SSE vs AVX vs AVX-512

Function frame provides a way to tell prolog/epilog inserter to use AVX instructions instead of SSE. Use set_avx_enabled() and set_avx512_enabled() to enable AVX and/or AVX-512, respectively. Enabling AVX-512 is mostly for Compiler as it would use 32 SIMD registers instead of 16 when enabled.

Note

If your code uses AVX instructions and AVX is not enabled there would be a performance hit in case that some registers had to be saved/restored in function's prolog/epilog, respectively. Thus, it's recommended to always let the function frame know about the use of AVX.

Function Frame Structure

Various properties can contribute to the size and structure of the function frame. The function frame in most cases won't use all of the properties illustrated (for example Spill Zone and Red Zone are never used together).

+-----------------------------+
| Arguments Passed by Stack |
+-----------------------------+
| Spill Zone |
+-----------------------------+ <- Stack offset (args) starts from here.
| Return Address, if Pushed |
+-----------------------------+ <- Stack pointer (SP) upon entry.
| Save/Restore Stack. |
+-----------------------------+-----------------------------+
| Local Stack | |
+-----------------------------+ Final Stack |
| Call Stack | |
+-----------------------------+-----------------------------+ <- SP after prolog.
| Red Zone |
+-----------------------------+

Static Public Attributes

Constants

Public Types

Types

Member Functions

Construction & Destruction

Initialization & Reset

Overloaded Operators

Accessors

void add_dirty_regs(const Reg& reg, Args&&... args) noexcept
void add_unavailable_regs(const Reg& reg, Args&&... args) noexcept

Finalization

FuncFrame::FuncFrame()defaultnoexcept[1/2][¶]

Creates a default constructed function frame, which has initialized all members to their default values.

FuncFrame::FuncFrame(
const FuncFrame& other
)defaultnoexcept[2/2][¶]

Creates a copy of other function frame.

Error FuncFrame::init(
const FuncDetail& func
)noexcept[¶]

Initializes the function frame based on func detail.

void FuncFrame::reset()noexcept[¶]

Resets the function frame into its default constructed state.

FuncFrame& FuncFrame::operator=(
const FuncFrame& other
)defaultnoexcept[¶]

Copy assignment - function frame is copy assignable.

Arch FuncFrame::arch() constnodiscardnoexcept[¶]

Returns the target architecture of the function frame.

FuncAttributes FuncFrame::attributes() constnodiscardnoexcept[¶]

Returns function frame attributes, see Attributes.

bool FuncFrame::has_attribute(
FuncAttributes attr
) constnodiscardnoexcept[¶]

Checks whether the FuncFame contains an attribute attr.

void FuncFrame::add_attributes(
FuncAttributes attrs
)noexcept[¶]

Adds attributes attrs to the FuncFrame.

void FuncFrame::clear_attributes(
FuncAttributes attrs
)noexcept[¶]

Clears attributes attrs from the FrameFrame.

bool FuncFrame::has_var_args() constnodiscardnoexcept[¶]

Tests whether the function has variable number of arguments.

void FuncFrame::set_var_args()noexcept[¶]

Sets the variable arguments flag.

void FuncFrame::reset_var_args()noexcept[¶]

Resets variable arguments flag.

bool FuncFrame::has_preserved_fp() constnodiscardnoexcept[¶]

Tests whether the function preserves frame pointer (EBP|ESP on X86).

void FuncFrame::set_preserved_fp()noexcept[¶]

Enables preserved frame pointer.

void FuncFrame::reset_preserved_fp()noexcept[¶]

Disables preserved frame pointer.

bool FuncFrame::has_func_calls() constnodiscardnoexcept[¶]

Tests whether the function calls other functions.

void FuncFrame::set_func_calls()noexcept[¶]

Sets FuncAttributes::kHasFuncCalls to true.

void FuncFrame::reset_func_calls()noexcept[¶]

Sets FuncAttributes::kHasFuncCalls to false.

bool FuncFrame::has_indirect_branch_protection() constnodiscardnoexcept[¶]

Tests whether the function uses indirect branch protection, see FuncAttributes::kIndirectBranchProtection.

void FuncFrame::set_indirect_branch_protection()noexcept[¶]

Enabled indirect branch protection (sets FuncAttributes::kIndirectBranchProtection attribute to true).

void FuncFrame::reset_indirect_branch_protection()noexcept[¶]

Disables indirect branch protection (sets FuncAttributes::kIndirectBranchProtection attribute to false).

bool FuncFrame::is_avx_enabled() constnodiscardnoexcept[¶]

Tests whether the function has AVX enabled.

void FuncFrame::set_avx_enabled()noexcept[¶]

Enables AVX use.

void FuncFrame::reset_avx_enabled()noexcept[¶]

Disables AVX use.

bool FuncFrame::is_avx512_enabled() constnodiscardnoexcept[¶]

Tests whether the function has AVX-512 enabled.

void FuncFrame::set_avx512_enabled()noexcept[¶]

Enables AVX-512 use.

void FuncFrame::reset_avx512_enabled()noexcept[¶]

Disables AVX-512 use.

bool FuncFrame::has_mmx_cleanup() constnodiscardnoexcept[¶]

Tests whether the function has MMX cleanup - 'emms' instruction in epilog.

void FuncFrame::set_mmx_cleanup()noexcept[¶]

Enables MMX cleanup.

void FuncFrame::reset_mmx_cleanup()noexcept[¶]

Disables MMX cleanup.

bool FuncFrame::has_avx_cleanup() constnodiscardnoexcept[¶]

Tests whether the function has AVX cleanup - 'vzeroupper' instruction in epilog.

void FuncFrame::set_avx_cleanup()noexcept[¶]

Enables AVX cleanup.

void FuncFrame::reset_avx_cleanup()noexcept[¶]

Disables AVX cleanup.

bool FuncFrame::has_call_stack() constnodiscardnoexcept[¶]

Tests whether the function uses call stack.

bool FuncFrame::has_local_stack() constnodiscardnoexcept[¶]

Tests whether the function uses local stack.

bool FuncFrame::has_aligned_vec_save_restore() constnodiscardnoexcept[¶]

Tests whether vector registers can be saved and restored by using aligned reads and writes.

bool FuncFrame::has_dynamic_alignment() constnodiscardnoexcept[¶]

Tests whether the function has to align stack dynamically.

bool FuncFrame::has_red_zone() constnodiscardnoexcept[¶]

Tests whether the calling convention specifies 'Red Zone'.

uint32_t FuncFrame::red_zone_size() constnodiscardnoexcept[¶]

Returns the size of 'Red Zone'.

bool FuncFrame::has_spill_zone() constnodiscardnoexcept[¶]

Tests whether the calling convention specifies 'Spill Zone'.

uint32_t FuncFrame::spill_zone_size() constnodiscardnoexcept[¶]

Returns the size of 'Spill Zone'.

void FuncFrame::reset_red_zone()noexcept[¶]

Resets the size of red zone, which would disable it entirely.

Note

Red zone is currently only used by an AMD64 SystemV calling convention, which expects 128 bytes of stack to be accessible below stack pointer. These bytes are then accessible within the function and Compiler can use this space as a spill area. However, sometimes it's better to disallow the use of red zone in case that a user wants to use this stack for a custom purpose.

uint32_t FuncFrame::natural_stack_alignment() constnodiscardnoexcept[¶]

Returns natural stack alignment (guaranteed stack alignment upon entry).

uint32_t FuncFrame::min_dynamic_alignment() constnodiscardnoexcept[¶]

Returns natural stack alignment (guaranteed stack alignment upon entry).

bool FuncFrame::has_callee_stack_cleanup() constnodiscardnoexcept[¶]

Tests whether the callee must adjust SP before returning (X86-STDCALL only)

uint32_t FuncFrame::callee_stack_cleanup() constnodiscardnoexcept[¶]

Returns home many bytes of the stack the callee must adjust before returning (X86-STDCALL only)

uint32_t FuncFrame::call_stack_alignment() constnodiscardnoexcept[¶]

Returns call stack alignment.

uint32_t FuncFrame::local_stack_alignment() constnodiscardnoexcept[¶]

Returns local stack alignment.

uint32_t FuncFrame::final_stack_alignment() constnodiscardnoexcept[¶]

Returns final stack alignment (the maximum value of call, local, and natural stack alignments).

void FuncFrame::set_call_stack_alignment(
uint32_t alignment
)noexcept[¶]

Sets call stack alignment.

Note

This also updates the final stack alignment.

void FuncFrame::set_local_stack_alignment(
uint32_t value
)noexcept[¶]

Sets local stack alignment.

Note

This also updates the final stack alignment.

void FuncFrame::update_call_stack_alignment(
uint32_t alignment
)noexcept[¶]

Combines call stack alignment with alignment, updating it to the greater value.

Note

This also updates the final stack alignment.

void FuncFrame::update_local_stack_alignment(
uint32_t alignment
)noexcept[¶]

Combines local stack alignment with alignment, updating it to the greater value.

Note

This also updates the final stack alignment.

uint32_t FuncFrame::call_stack_size() constnodiscardnoexcept[¶]

Returns call stack size.

uint32_t FuncFrame::local_stack_size() constnodiscardnoexcept[¶]

Returns local stack size.

void FuncFrame::set_call_stack_size(
uint32_t size
)noexcept[¶]

Sets call stack size.

void FuncFrame::set_local_stack_size(
uint32_t size
)noexcept[¶]

Sets local stack size.

void FuncFrame::update_call_stack_size(
uint32_t size
)noexcept[¶]

Combines call stack size with size, updating it to the greater value.

void FuncFrame::update_local_stack_size(
uint32_t size
)noexcept[¶]

Combines local stack size with size, updating it to the greater value.

uint32_t FuncFrame::final_stack_size() constnodiscardnoexcept[¶]

Returns final stack size (only valid after the FuncFrame is finalized).

uint32_t FuncFrame::local_stack_offset() constnodiscardnoexcept[¶]

Returns an offset to access the local stack (non-zero only if call stack is used).

bool FuncFrame::has_da_offset() constnodiscardnoexcept[¶]

Tests whether the function prolog/epilog requires a memory slot for storing unaligned SP.

uint32_t FuncFrame::da_offset() constnodiscardnoexcept[¶]

Returns a memory offset used to store DA (dynamic alignment) slot (relative to SP).

RegMask FuncFrame::dirty_regs(
RegGroup group
) constnodiscardnoexcept[1/2][¶]

Returns mask of registers of the given register group that are modified by the function. The engine would then calculate which registers must be saved & restored by the function by using the data provided by the calling convention.

void FuncFrame::set_dirty_regs(
RegGroup group,
RegMask regs
)noexcept[¶]

Sets which registers (as a mask) are modified by the function.

Remarks

Please note that this will completely overwrite the existing register mask, use add_dirty_regs() to modify the existing register mask.

void FuncFrame::add_dirty_regs(
RegGroup group,
RegMask regs
)noexcept[1/3][¶]

Adds which registers (as a mask) are modified by the function.

void FuncFrame::add_dirty_regs(
const Reg& reg
)noexcept[2/3][¶]

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename... Args>
void FuncFrame::add_dirty_regs(
const Reg& reg,
Args&&... args
)noexcept[3/3][¶]

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void FuncFrame::set_all_dirty()noexcept[1/2][¶]

A helper function to set all registers from all register groups dirty.

Note

This should not be used in general as it's the most pessimistic case. However, it can be used for testing or in cases in which all registers are considered clobbered.

void FuncFrame::set_all_dirty(
RegGroup group
)noexcept[2/2][¶]

A helper function to set all registers from the given register group dirty.

RegMask FuncFrame::saved_regs(
RegGroup group
) constnodiscardnoexcept[¶]

Returns a calculated mask of registers of the given group that will be saved and restored in the function's prolog and epilog, respectively. The register mask is calculated from both dirty_regs (provided by user) and preserved_mask (provided by the calling convention).

const RegMasks& FuncFrame::dirty_regs() constnodiscardnoexcept[2/2][¶]

Returns all dirty registers as a Support::Array<> type.

const RegMasks& FuncFrame::preserved_regs() constnodiscardnoexcept[1/2][¶]

Returns all preserved registers as a Support::Array<> type.

RegMask FuncFrame::preserved_regs(
RegGroup group
) constnodiscardnoexcept[2/2][¶]

Returns the mask of preserved registers of the given register group.

Preserved registers are those that must survive the function call unmodified. The function can only modify preserved registers it they are saved and restored in function's prolog and epilog, respectively.

void FuncFrame::set_unavailable_regs(
RegGroup group,
RegMask regs
)noexcept[¶]

Sets which registers (as a mask) are unavailable for allocation.

Note

This completely overwrites the current unavailable mask.

void FuncFrame::add_unavailable_regs(
RegGroup group,
RegMask regs
)noexcept[1/3][¶]

Adds registers (as a mask) to the unavailable set.

void FuncFrame::add_unavailable_regs(
const Reg& reg
)noexcept[2/3][¶]

Adds a single register to the unavailable set.

template<typename... Args>
void FuncFrame::add_unavailable_regs(
const Reg& reg,
Args&&... args
)noexcept[3/3][¶]

Adds multiple registers to the unavailable set.

void FuncFrame::clear_unavailable_regs()noexcept[1/2][¶]

Clears all unavailable registers across all register groups (i.e., makes them all available again).

void FuncFrame::clear_unavailable_regs(
RegGroup group
)noexcept[2/2][¶]

Clears all unavailable registers in a specific register group.

RegMask FuncFrame::unavailable_regs(
RegGroup group
) constnodiscardnoexcept[1/2][¶]

Returns the set of unavailable registers for the given group.

const RegMasks& FuncFrame::unavailable_regs() constnodiscardnoexcept[2/2][¶]

Returns all unavailable registers as a Support::Array<>.

uint32_t FuncFrame::save_restore_reg_size(
RegGroup group
) constnodiscardnoexcept[¶]

Returns the size of a save-restore are for the required register group.

uint32_t FuncFrame::save_restore_alignment(
RegGroup group
) constnodiscardnoexcept[¶]

Returns the alignment that must be guaranteed to save/restore the required register group.

uint32_t FuncFrame::push_pop_save_size() constnodiscardnoexcept[¶]

Returns stack size required to save/restore registers via push/pop.

uint32_t FuncFrame::push_pop_save_offset() constnodiscardnoexcept[¶]

Returns an offset to the stack where registers are saved via push/pop.

uint32_t FuncFrame::extra_reg_save_size() constnodiscardnoexcept[¶]

Returns stack size required to save/restore extra registers that don't use push/pop/

Note

On X86 this covers all registers except GP registers, on other architectures it can be always zero (for example AArch64 saves all registers via push/pop like instructions, so this would be zero).

uint32_t FuncFrame::extra_reg_save_offset() constnodiscardnoexcept[¶]

Returns an offset to the stack where extra registers are saved.

bool FuncFrame::has_stack_adjustment() constnodiscardnoexcept[¶]

Tests whether the functions contains stack adjustment.

uint32_t FuncFrame::stack_adjustment() constnodiscardnoexcept[¶]

Returns function's stack adjustment used in function's prolog and epilog.

If the returned value is zero it means that the stack is not adjusted. This can mean both that the stack is not used and/or the stack is only adjusted by instructions that pust/pop registers into/from stack.

uint32_t FuncFrame::kTagInvalidOffset = 0xFFFFFFFFustaticconstexpr[¶]

Tag used to inform that some offset is invalid.

FuncAttributes FuncFrame::_attributes {}[¶]

Function attributes.

Arch FuncFrame::_arch {}[¶]

Target architecture.

uint8_t FuncFrame::_sp_reg_id = uint8_t(
Reg::kIdBad
)[¶]

SP register ID (to access call stack and local stack).

uint8_t FuncFrame::_sa_reg_id = uint8_t(
Reg::kIdBad
)[¶]

SA register ID (to access stack arguments).

uint8_t FuncFrame::_red_zone_size = 0[¶]

Red zone size (copied from CallConv).

uint8_t FuncFrame::_spill_zone_size = 0[¶]

Spill zone size (copied from CallConv).

uint8_t FuncFrame::_natural_stack_alignment = 0[¶]

Natural stack alignment (copied from CallConv).

uint8_t FuncFrame::_min_dynamic_alignment = 0[¶]

Minimum stack alignment to turn on dynamic alignment.

uint8_t FuncFrame::_call_stack_alignment = 0[¶]

Call stack alignment.

uint8_t FuncFrame::_local_stack_alignment = 0[¶]

Local stack alignment.

uint8_t FuncFrame::_final_stack_alignment = 0[¶]

Final stack alignment.

uint16_t FuncFrame::_callee_stack_cleanup = 0[¶]

Adjustment of the stack before returning (X86-STDCALL).

uint32_t FuncFrame::_call_stack_size = 0[¶]

Call stack size.

uint32_t FuncFrame::_local_stack_size = 0[¶]

Local stack size.

uint32_t FuncFrame::_final_stack_size = 0[¶]

Final stack size (sum of call stack and local stack).

uint32_t FuncFrame::_local_stack_offset = 0[¶]

Local stack offset (non-zero only if call stack is used).

uint32_t FuncFrame::_da_offset = 0[¶]

Offset relative to SP that contains previous SP (before alignment).

uint32_t FuncFrame::_sa_offset_from_sp = 0[¶]

Offset of the first stack argument relative to SP.

uint32_t FuncFrame::_sa_offset_from_sa = 0[¶]

Offset of the first stack argument relative to SA (_sa_reg_id or FP).

uint32_t FuncFrame::_stack_adjustment = 0[¶]

Local stack adjustment in prolog/epilog.

RegMasks FuncFrame::_dirty_regs {}[¶]

Registers that are dirty.

RegMasks FuncFrame::_preserved_regs {}[¶]

Registers that must be preserved (copied from CallConv).

RegMasks FuncFrame::_unavailable_regs {}[¶]

Registers that are unavailable.

Support::Array<uint8_t, Globals::kNumVirtGroups>FuncFrame::_save_restore_reg_size {}[¶]

Size to save/restore per register group.

Support::Array<uint8_t, Globals::kNumVirtGroups>FuncFrame::_save_restore_alignment {}[¶]

Alignment of save/restore area per register group.

uint16_t FuncFrame::_push_pop_save_size = 0[¶]

Stack size required to save registers with push/pop.

uint16_t FuncFrame::_extra_reg_save_size = 0[¶]

Stack size required to save extra registers that cannot use push/pop.

uint32_t FuncFrame::_push_pop_save_offset = 0[¶]

Offset where registers saved/restored via push/pop are stored.

uint32_t FuncFrame::_extra_reg_save_offset = 0[¶]

Offset where extra registers that cannot use push/pop are stored.

© 2018-2025 AsmJit Team | GitHub | Chat | Blog

AsmJit and AsmTK libraries are open source software released under the Zlib license and can be used safely in any open-source or commercial product, statically or dynamically linked, and without having to advertise the use of the libraries. Code snippets and examples are released into public domain, see Unlicense for more details.