clang/Basic/AttrDocs.td

115 initialization of objects declared at namespace scope in C++. The priority is
206 declared with static storage duration, such as globals, class static data
260 out of functions.
277 resolve multiversioned functions. This form of multiversioning provides a
301 A dispatching (or resolving) function can be declared anywhere in a project's
304 are not expected to be defined, only declared. If such a marked function has a
358 compilation of functions for the device part can be found in the SYCL 1.2.1
401 - The function must return void. The compiler reuses the body of marked functions to
411 A function declared as ``_Noreturn`` shall not return to its caller. The
412 compiler will generate a diagnostic for a function declared as ``_Noreturn``
422 A function declared as ``[[noreturn]]`` shall not return to its caller. The
423 compiler will generate a diagnostic for a function declared as ``[[noreturn]]``
460 is the result of a function call (even functions returning void must use
467 caller and callee must match, and they must not be variadic functions or have
534 The ``alloc_size`` attribute can be placed on functions that return pointers in
644 bool-returning constexpr function declared with the arguments of the function
694 Note that functions with one or more ``enable_if`` attributes may not have
809 .. Note:: The mangling of functions with parameters that are annotated with
811   using ``__asm__("foo")`` to explicitly name your functions, thus preserving
812   your ABI; also, non-overloadable C functions with ``pass_object_size`` are
951 The declaration of ``overloadable`` functions is restricted to function
953 attribute, then all declarations and definitions of functions with that name,
980 However, ``overloadable`` functions are allowed to use a ellipsis even if there
988 Functions declared with the ``overloadable`` attribute have their names mangled
990 ``tgsin`` functions in our motivating example get the mangled names
994 * Future versions of Clang may change the name mangling of functions overloaded
997   functions.
1000   because names will already be mangled and functions are already overloadable.
1006 name as other ``overloadable`` functions may omit the ``overloadable``
1062 convention (e.g. functions starting with "get" are assumed to return at
1115 The family of attributes ``X_returns_X_retained`` can be added to functions,
1117 Attributes ``X_consumed`` can be added to parameters of methods, functions,
1146 optimizations. This is required for the implementation of functions with
1188 translated into the LLVM ``convergent`` attribute, which indicates that the call
1980   other AAPCS functions to be called.
1982   itself is designed in such a way that functions obeying the normal AAPCS ABI
2081 of the distance between the functions.
2103 of the distance between the functions.
2145 The first instruction of an interrupt handler declared with this attribute is a SEI
2159 Interrupt handler functions defined with the signal attribute do not re-enable interrupts.
2202 All multiversioned functions must contain a ``default`` (fallback)
2363 This means it is more efficient to call such functions from code that performs
2366 floating-point or vector math library functions, which are typically leaf
2367 functions that require a small number of registers.
2372 for leaf functions.
2386 stack. This attribute has no effect on variadic functions, and all parameters
2414 not support variadic calls or unprototyped functions in C, and has no effect on
2428 unprototyped functions in C, and has no effect on x86_64 targets. This calling
2455 convention does not support variadic calls or unprototyped functions in C, and
2539 The ``return_typestate`` attribute can be applied to functions or parameters.
2656 * checking types of variadic functions' arguments for functions like
2690 This attribute is primarily useful for checking arguments of variadic functions
2766   * **Type tag that is a reference to a declared identifier.**
2894    for functions that accept a ``va_list`` argument (for example, ``vprintf``).
2896    functions. Clang does not warn if the format string comes from a function
2973 symbol name for a C++ variable declared as ``int cppvar;`` would be
2995 request new builtin functions.
3088 user-declared functions. For example:
3137     // user-provided special functions trivial.
3442 function parameters in non-kernel functions can have the generic address space
3456 with the constant address space qualifier can be declared in any scope and must
3519 declared in the private address space. Function arguments are always in the
4046 The ``declare target`` directive specifies that variables and functions are mapped
4129 declarations with the same name. The template parameters for the base functions
4140 in library functions. Functions marked with the ``leaf`` attribute are not allowed
4191 selectively disabling the stack protector on some functions when building with
4212 bound calls. Objective-c methods, and functions marked as ``always_inline``
4268 is particularly useful on functions in the C Standard Library that are
4341 This attribute can be used on static and non-static member functions of class
4363 Marking virtual functions as ``disable_tail_calls`` is legal.
4396 The user can call functions specified with the 'no_caller_saved_registers'
4510 ``swiftcall`` does not support variadic arguments or unprototyped functions.
4548 compatible with the low-level conventions of Swift async functions,
4643 Making indirect results explicit in the signature allows C functions to
4766 It allows the C intrinsic functions to be declared using the names defined
4770 This ensures that both functions are recognized as that clang builtin,
4775 C intrinsic functions; it is intended for use only inside ``arm_*.h`` and
4777 for clang builtin functions.
4791 general this requires the template to be declared at least twice. For example:
4822 The idea behind this convention is to support calls to runtime functions
4862 The idea behind this convention is to support calls to runtime functions
4863 that don't need to call out to any other functions.
4875 type. This is useful when identifying functions, variables, or types that are
4905 declared entity. The entity must not have weak linkage; for example, in C++,
4929 In RenderScript, ``kernel`` functions are used to express data-parallel
4931 functions to run on computational resources such as multi-core CPUs and GPUs.
4943 ``[[clang::xray_always_instrument]]`` is used to mark member functions (in C++),
4944 methods (in Objective C), and free functions (in C, C++, and Objective C) to be
4979 functions that have an argument with a transparent union type. The compiler
5062 - implement a non-direct method (as declared in any class interface) with a direct method.
5065 ``@implementation`` within a single linkage unit were declared in an
5075 ``@interface`` block, its class extensions, its categories, its declared protocols,
5078 An Objective-C property can be declared with the ``direct`` property
5081 declared elsewhere), the method is declared to be direct.
5093 ``@interface`` or ``@implementation`` to mark that methods declared
5098 method in the block is considered to be declared as direct. This includes any
5104 methods defined in the block are considered to be declared as direct unless
5105 they have been previously declared as non-direct in any interface of the class.
5148 WebAssembly functions are exported via string name. By default when a symbol
5269 A typical example where this attribute would be used is on functions that clear
5301 If a variable is declared with this attribute, clang doesn't access check or
5384 not present in the declared parameter list, or one that is, but is potentially
5388 The ``callback`` attribute, which is directly translated to ``callback``
5404 automatically recognized as broker functions. Further functions might be added
5479 * If any declaration that is declared ``inline`` is not declared ``extern``,
5484 * If all declarations that are declared ``inline`` are also declared
5547   be hardened. A user of this attribute may want to mark functions called by
5573 variables, functions, methods, or blocks to opt into
5601 functions that follow it to only release arguments passed to them when they
5605 is applied in order to specify which functions are expected to follow the
5609 added to arbitrary functions that need to follow the same convention - for
5610 example, a user can add them to auxiliary functions called by the server routine
5621 The ``__declspec(allocator)`` attribute is applied to functions that allocate
5645 to small wrapper functions that are not inlined and that do nothing more than
5648 the directive. Typically, this usage is limited to very small functions that
5660 could be accessed on the host side and, on the device side, might be translated
5671 could be accessed on the host side and, on the device side, might be translated
5682 registered by ``__hipRegisterManagedVariable`` in init functions. The HIP runtime allocates
5760 It allows the intrinsic functions to
5761 be declared using the names defined in ACLE, and still be recognized
5766 will have the same attribute. This ensures that both functions are
5772 intrinsic functions; it is intended for use only inside ``arm_*.h``
5774 clang builtin functions.
5791 functions in a derived class.
6016 …e Microsoft Docs on Inline Functions: https://docs.microsoft.com/en-us/cpp/cpp/inline-functions-cpp
6027   The ``enforce_tcb`` attribute can be placed on functions to enforce that a
6043   continue to check the functions called from within the leaf function.