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

asmjit::FuncSignature Struct Reference [¶]

Function signature.

Contains information about a function return type, count of arguments, and their TypeIds. Function signature is a low level structure which doesn't contain platform specific or calling convention specific information. It's typically used to describe function arguments in a C-API like form, which is then used to calculate a FuncDetail instance, which then maps function signature into a platform and calling convention specific format.

Function signature can be built either dynamically by using add_arg() and add_arg_t() functionality, or dynamically by using a template-based FuncSignature::build() function, which maps template types into a function signature.

Static Public Attributes

Constants

Member Functions

Overloaded Operators

Initialization & Reset

Equality & Comparison

Accessors

constexpr void set_ret_t() noexcept
void set_arg_t(uint32_t index) noexcept
void add_arg_t() noexcept

Construction & Destruction

constexpr FuncSignature(CallConvId call_conv_id, uint32_t va_index, TypeId ret, Args&&... args) noexcept
static constexpr FuncSignature build(CallConvId call_conv_id = CallConvId::kCDecl, uint32_t va_index = kNoVarArgs) noexcept

FuncSignature::FuncSignature()constexprdefault[1/4][¶]

Default constructed function signature, initialized to CallConvId::kCDecl, having no return value and no arguments.

FuncSignature::FuncSignature(
const FuncSignature& other
)constexprdefault[2/4][¶]

Copy constructor, which is initialized to the same function signature as other.

FuncSignature::FuncSignature(
CallConvId call_conv_id,
uint32_t va_index = kNoVarArgs
)constexprnoexcept[3/4][¶]

Initializes the function signature with calling convention id call_conv_id and variable argument's index va_index.

template<typename... Args>
FuncSignature::FuncSignature(
CallConvId call_conv_id,
uint32_t va_index,
TypeId ret,
Args&&... args
)constexprnoexcept[4/4][¶]

Initializes the function signature with calling convention id call_conv_id, va_index, return value, and function arguments.

template<typename... RetValueAndArgs>
FuncSignature FuncSignature::build(
CallConvId call_conv_id = CallConvId::kCDecl,
uint32_t va_index = kNoVarArgs
)constexprstaticnodiscardnoexcept[¶]

Builds a function signature based on RetValueAndArgs. The first template argument is a function return type, and function arguments follow.

Note

This function returns a new function signature, which can be passed to functions where it's required. It's a convenience function that allows to build function signature statically based on types known at compile time, which is common in JIT code generation.

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

Copy assignment - function signature can be copied by value.

bool FuncSignature::operator==(
const FuncSignature& other
) constnodiscardnoexcept[¶]

Compares this function signature with other for equality..

bool FuncSignature::operator!=(
const FuncSignature& other
) constnodiscardnoexcept[¶]

Compares this function signature with other for inequality..

void FuncSignature::reset()noexcept[¶]

Resets this function signature to a default constructed state.

bool FuncSignature::equals(
const FuncSignature& other
) constnodiscardnoexcept[¶]

Compares this function signature with other for equality..

CallConvId FuncSignature::call_conv_id() constnodiscardconstexprnoexcept[¶]

Returns the calling convention.

void FuncSignature::set_call_conv_id(
CallConvId call_conv_id
)constexprnoexcept[¶]

Sets the calling convention to call_conv_id;.

bool FuncSignature::has_ret() constnodiscardconstexprnoexcept[¶]

Tests whether the function signature has a return value.

TypeId FuncSignature::ret() constnodiscardconstexprnoexcept[¶]

Returns the type of the return value.

void FuncSignature::set_ret(
TypeId ret_type
)constexprnoexcept[¶]

Sets the return type to ret_type.

template<typename T>
void FuncSignature::set_ret_t()constexprnoexcept[¶]

Sets the return type based on T.

const TypeId* FuncSignature::args() constnodiscardconstexprnoexcept[¶]

Returns the array of function arguments' types.

uint32_t FuncSignature::arg_count() constnodiscardconstexprnoexcept[¶]

Returns the number of function arguments.

TypeId FuncSignature::arg(
uint32_t i
) constnodiscardnoexcept[¶]

Returns the type of the argument at index i.

void FuncSignature::set_arg(
uint32_t index,
TypeId arg_type
)noexcept[¶]

Sets the argument at index index to arg_type.

template<typename T>
void FuncSignature::set_arg_t(
uint32_t index
)noexcept[¶]

Sets the argument at index i to the type based on T.

bool FuncSignature::can_add_arg() constnodiscardnoexcept[¶]

Tests whether an argument can be added to the signature, use before calling add_arg() and add_arg_t().

Note

If you know that you are not adding more arguments than Globals::kMaxFuncArgs then it's not necessary to use this function. However, if you are adding arguments based on user input, for example, then either check the number of arguments before using function signature or use can_add_arg() before actually adding them to the function signature.

void FuncSignature::add_arg(
TypeId type
)noexcept[¶]

Appends an argument of type to the function prototype.

template<typename T>
void FuncSignature::add_arg_t()noexcept[¶]

Appends an argument of type based on T to the function prototype.

bool FuncSignature::has_var_args() constnodiscardnoexcept[¶]

Tests whether the function has variable number of arguments (...).

uint32_t FuncSignature::va_index() constnodiscardnoexcept[¶]

Returns the variable arguments (...) index, kNoVarArgs if none.

void FuncSignature::set_va_index(
uint32_t index
)noexcept[¶]

Sets the variable arguments (...) index to index.

void FuncSignature::reset_va_index()noexcept[¶]

Resets the variable arguments index (making it a non-va function).

uint8_t FuncSignature::kNoVarArgs = 0xFFustaticconstexpr[¶]

Doesn't have variable number of arguments (...).

CallConvId FuncSignature::_call_conv_id = CallConvId::kCDecl[¶]

Calling convention id.

uint8_t FuncSignature::_arg_count = 0[¶]

Count of arguments.

uint8_t FuncSignature::_va_index = kNoVarArgs[¶]

Index of a first VA or kNoVarArgs.

TypeId FuncSignature::_ret = TypeId::kVoid[¶]

Return value TypeId.

uint8_t FuncSignature::_reserved[4] {}[¶]

Reserved for future use.

TypeId FuncSignature::_args[Globals::kMaxFuncArgs] {}[¶]

Function argument TypeIds.

© 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.