AttributeKind

This attribute indicates that, when emitting the prologue and epilogue, the backend should forcibly align the stack pointer.

This attribute indicates that the annotated function will always return at least a given number of bytes (or null).

This attribute indicates that the inliner should attempt to inline this function into callers whenever possible, ignoring any active inlining size threshold for this caller.

This indicates that the callee function at a call site should be recognized as a built-in function, even though the function’s declaration uses the nobuiltin attribute

This attribute indicates that this function is rarely called.

In some parallel execution models, there exist operations that cannot be made control-dependent on any additional values.

This attribute indicates that the function may only access memory that is not accessible by the module being compiled.

This attribute indicates that the function may only access memory that is either not accessible by the module being compiled, or is pointed to by its pointer arguments.

This attribute indicates that the source code contained a hint that inlin inlining this function is desirable (such as the “inline” keyword in C/C++).

This attribute indicates that the function should be added to a jump-instruction table at code-generation time, and that all address-taken references to this function should be replaced with a reference to the appropriate jump-instruction-table function pointer.

This attribute suggests that optimization passes and code generator passes make choices that keep the code size of this function as small as possible and perform optimizations that may sacrifice runtime performance in order to minimize the size of the generated code.

This attribute disables prologue / epilogue emission for the function.

When this attribute is set to true, the jump tables and lookup tables that can be generated from a switch case lowering are disabled.

This indicates that the callee function at a call site is not recognized as a built-in function.

This attribute indicates that calls to the function cannot be duplicated.

This attributes disables implicit floating point instructions.

This attribute indicates that the inliner should never inline this function in any situation.

This attribute suppresses lazy symbol binding for the function.

This attribute indicates that the code generator should not use a red zone, even if the target-specific ABI normally permits it.

This function attribute indicates that the function never returns normally.

This function attribute indicates that the function does not call itself either directly or indirectly down any possible call path.

This function attribute indicates that the function never raises an exception.

This function attribute indicates that most optimization passes will skip this function, with the exception of interprocedural optimization passes.

This attribute suggests that optimization passes and code generator passes make choices that keep the code size of this function low, and otherwise do optimizations specifically to reduce code size as long as they do not significantly impact runtime performance.

This attribute indicates that the function computes its result (or decides to unwind an exception) based strictly on its arguments, without dereferencing any pointer arguments or otherwise accessing any mutable state (e.g. memory, control registers, etc) visible to caller functions.

This attribute indicates that the function does not write through any pointer arguments (including byval arguments) or otherwise modify any state (e.g. memory, control registers, etc) visible to caller functions.

This attribute indicates that the function may write to but does not read read from memory.

This attribute indicates that the only memory accesses inside function are loads and stores from objects pointed to by its pointer-typed arguments, with arbitrary offsets.

This attribute indicates that this function can return twice.

This attribute indicates that SafeStack protection is enabled for this function.

This attribute indicates that AddressSanitizer checks (dynamic address safety analysis) are enabled for this function.

This attribute indicates that MemorySanitizer checks (dynamic detection of accesses to uninitialized memory) are enabled for this function.

This attribute indicates that ThreadSanitizer checks (dynamic thread safety analysis) are enabled for this function.

This attribute indicates that HWAddressSanitizer checks (dynamic address safety analysis based on tagged pointers) are enabled for this function.

This function attribute indicates that the function does not have any effects besides calculating its result and does not have undefined behavior.

This attribute indicates that the function should emit a stack smashing protector.

This attribute indicates that the function should always emit a stack smashing protector

This attribute indicates that the function should emit a stack smashing protector.

This attribute indicates that the function was called from a scope that requires strict floating point semantics.

This attribute indicates that the ABI being targeted requires that an unwind table entry be produced for this function even if we can show that no exceptions passes by it.

This indicates to the code generator that the parameter or return value should be zero-extended to the extent required by the target’s ABI by the caller (for a parameter) or the callee (for a return value).

This indicates to the code generator that the parameter or return value should be sign-extended to the extent required by the target’s ABI (which is usually 32-bits) by the caller (for a parameter) or the callee (for a return value).

This indicates that this parameter or return value should be treated in a special target-dependent fashion while emitting code for a function call or return.

This indicates that the pointer parameter should really be passed by value to the function.

The inalloca argument attribute allows the caller to take the address of outgoing stack arguments

This indicates that the pointer parameter specifies the address of a structure that is the return value of the function in the source program.

This indicates that the pointer value may be assumed by the optimizer to have the specified alignment.

This indicates that objects accessed via pointer values based on the argument or return value are not also accessed, during the execution of the function, via pointer values not based on the argument or return value.

The noalias attribute may appear in one of two location: on arguments types or on return types. On argument types, noalias acts like the restrict keyword in C and C++ and implies that no other pointer value points to this object. On return types, noalias implies that the returned pointer is not aliased by any other pointer in the program.

Practically, this allows LLVM to reorder accesses to this memory.

This indicates that the callee does not make any copies of the pointer that outlive the callee itself.

This indicates that the pointer parameter can be excised using the trampoline intrinsics.

This indicates that the function always returns the argument as its return value.

This indicates that the parameter or return pointer is not null.

This indicates that the parameter or return pointer is dereferenceable.

This indicates that the parameter or return value isn’t both non-null and non-dereferenceable (up to n bytes) at the same time.

This indicates that the parameter is the self/context parameter.

This attribute is motivated to model and optimize Swift error handling.