1 //==--- AttrDocs.td - Attribute documentation ----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===---------------------------------------------------------------------===//
10 def GlobalDocumentation {
12 -------------------------------------------------------------------
13 NOTE: This file is automatically generated by running clang-tblgen
14 -gen-attr-docs. Do not edit this file by hand!!
15 -------------------------------------------------------------------
26 This page lists the attributes currently supported by Clang.
30 def SectionDocs : Documentation {
31 let Category = DocCatVariable;
33 The ``section`` attribute allows you to specify a specific section a
34 global variable or function should be in after translation.
36 let Heading = "section (gnu::section, __declspec(allocate))";
39 def InitSegDocs : Documentation {
40 let Category = DocCatVariable;
42 The attribute applied by ``pragma init_seg()`` controls the section into
43 which global initialization function pointers are emitted. It is only
44 available with ``-fms-extensions``. Typically, this function pointer is
45 emitted into ``.CRT$XCU`` on Windows. The user can change the order of
46 initialization by using a different section name with the same
47 ``.CRT$XC`` prefix and a suffix that sorts lexicographically before or
48 after the standard ``.CRT$XCU`` sections. See the init_seg_
49 documentation on MSDN for more information.
51 .. _init_seg: http://msdn.microsoft.com/en-us/library/7977wcck(v=vs.110).aspx
55 def TLSModelDocs : Documentation {
56 let Category = DocCatVariable;
58 The ``tls_model`` attribute allows you to specify which thread-local storage
59 model to use. It accepts the following strings:
66 TLS models are mutually exclusive.
70 def DLLExportDocs : Documentation {
71 let Category = DocCatVariable;
73 The ``__declspec(dllexport)`` attribute declares a variable, function, or
74 Objective-C interface to be exported from the module. It is available under the
75 ``-fdeclspec`` flag for compatibility with various compilers. The primary use
76 is for COFF object files which explicitly specify what interfaces are available
77 for external use. See the dllexport_ documentation on MSDN for more
80 .. _dllexport: https://msdn.microsoft.com/en-us/library/3y1sfaz2.aspx
84 def DLLImportDocs : Documentation {
85 let Category = DocCatVariable;
87 The ``__declspec(dllimport)`` attribute declares a variable, function, or
88 Objective-C interface to be imported from an external module. It is available
89 under the ``-fdeclspec`` flag for compatibility with various compilers. The
90 primary use is for COFF object files which explicitly specify what interfaces
91 are imported from external modules. See the dllimport_ documentation on MSDN
94 .. _dllimport: https://msdn.microsoft.com/en-us/library/3y1sfaz2.aspx
98 def ThreadDocs : Documentation {
99 let Category = DocCatVariable;
101 The ``__declspec(thread)`` attribute declares a variable with thread local
102 storage. It is available under the ``-fms-extensions`` flag for MSVC
103 compatibility. See the documentation for `__declspec(thread)`_ on MSDN.
105 .. _`__declspec(thread)`: http://msdn.microsoft.com/en-us/library/9w1sdazb.aspx
107 In Clang, ``__declspec(thread)`` is generally equivalent in functionality to the
108 GNU ``__thread`` keyword. The variable must not have a destructor and must have
109 a constant initializer, if any. The attribute only applies to variables
110 declared with static storage duration, such as globals, class static data
111 members, and static locals.
115 def CarriesDependencyDocs : Documentation {
116 let Category = DocCatFunction;
118 The ``carries_dependency`` attribute specifies dependency propagation into and
121 When specified on a function or Objective-C method, the ``carries_dependency``
122 attribute means that the return value carries a dependency out of the function,
123 so that the implementation need not constrain ordering upon return from that
124 function. Implementations of the function and its caller may choose to preserve
125 dependencies instead of emitting memory ordering instructions such as fences.
127 Note, this attribute does not change the meaning of the program, but may result
128 in generation of more efficient code.
132 def C11NoReturnDocs : Documentation {
133 let Category = DocCatFunction;
135 A function declared as ``_Noreturn`` shall not return to its caller. The
136 compiler will generate a diagnostic for a function declared as ``_Noreturn``
137 that appears to be capable of returning to its caller.
141 def CXX11NoReturnDocs : Documentation {
142 let Category = DocCatFunction;
144 A function declared as ``[[noreturn]]`` shall not return to its caller. The
145 compiler will generate a diagnostic for a function declared as ``[[noreturn]]``
146 that appears to be capable of returning to its caller.
150 def AssertCapabilityDocs : Documentation {
151 let Category = DocCatFunction;
152 let Heading = "assert_capability (assert_shared_capability, clang::assert_capability, clang::assert_shared_capability)";
154 Marks a function that dynamically tests whether a capability is held, and halts
155 the program if it is not held.
159 def AcquireCapabilityDocs : Documentation {
160 let Category = DocCatFunction;
161 let Heading = "acquire_capability (acquire_shared_capability, clang::acquire_capability, clang::acquire_shared_capability)";
163 Marks a function as acquiring a capability.
167 def TryAcquireCapabilityDocs : Documentation {
168 let Category = DocCatFunction;
169 let Heading = "try_acquire_capability (try_acquire_shared_capability, clang::try_acquire_capability, clang::try_acquire_shared_capability)";
171 Marks a function that attempts to acquire a capability. This function may fail to
172 actually acquire the capability; they accept a Boolean value determining
173 whether acquiring the capability means success (true), or failing to acquire
174 the capability means success (false).
178 def ReleaseCapabilityDocs : Documentation {
179 let Category = DocCatFunction;
180 let Heading = "release_capability (release_shared_capability, clang::release_capability, clang::release_shared_capability)";
182 Marks a function as releasing a capability.
186 def AssumeAlignedDocs : Documentation {
187 let Category = DocCatFunction;
189 Use ``__attribute__((assume_aligned(<alignment>[,<offset>]))`` on a function
190 declaration to specify that the return value of the function (which must be a
191 pointer type) has the specified offset, in bytes, from an address with the
192 specified alignment. The offset is taken to be zero if omitted.
196 // The returned pointer value has 32-byte alignment.
197 void *a() __attribute__((assume_aligned (32)));
199 // The returned pointer value is 4 bytes greater than an address having
200 // 32-byte alignment.
201 void *b() __attribute__((assume_aligned (32, 4)));
203 Note that this attribute provides information to the compiler regarding a
204 condition that the code already ensures is true. It does not cause the compiler
205 to enforce the provided alignment assumption.
209 def AllocSizeDocs : Documentation {
210 let Category = DocCatFunction;
212 The ``alloc_size`` attribute can be placed on functions that return pointers in
213 order to hint to the compiler how many bytes of memory will be available at the
214 returned poiner. ``alloc_size`` takes one or two arguments.
216 - ``alloc_size(N)`` implies that argument number N equals the number of
217 available bytes at the returned pointer.
218 - ``alloc_size(N, M)`` implies that the product of argument number N and
219 argument number M equals the number of available bytes at the returned
222 Argument numbers are 1-based.
224 An example of how to use ``alloc_size``
228 void *my_malloc(int a) __attribute__((alloc_size(1)));
229 void *my_calloc(int a, int b) __attribute__((alloc_size(1, 2)));
232 void *const p = my_malloc(100);
233 assert(__builtin_object_size(p, 0) == 100);
234 void *const a = my_calloc(20, 5);
235 assert(__builtin_object_size(a, 0) == 100);
238 .. Note:: This attribute works differently in clang than it does in GCC.
239 Specifically, clang will only trace ``const`` pointers (as above); we give up
240 on pointers that are not marked as ``const``. In the vast majority of cases,
241 this is unimportant, because LLVM has support for the ``alloc_size``
242 attribute. However, this may cause mildly unintuitive behavior when used with
243 other attributes, such as ``enable_if``.
247 def EnableIfDocs : Documentation {
248 let Category = DocCatFunction;
250 .. Note:: Some features of this attribute are experimental. The meaning of
251 multiple enable_if attributes on a single declaration is subject to change in
252 a future version of clang. Also, the ABI is not standardized and the name
253 mangling may change in future versions. To avoid that, use asm labels.
255 The ``enable_if`` attribute can be placed on function declarations to control
256 which overload is selected based on the values of the function's arguments.
257 When combined with the ``overloadable`` attribute, this feature is also
263 int isdigit(int c) __attribute__((enable_if(c <= -1 || c > 255, "chosen when 'c' is out of range"))) __attribute__((unavailable("'c' must have the value of an unsigned char or EOF")));
268 isdigit(-10); // results in a compile-time error.
271 The enable_if attribute takes two arguments, the first is an expression written
272 in terms of the function parameters, the second is a string explaining why this
273 overload candidate could not be selected to be displayed in diagnostics. The
274 expression is part of the function signature for the purposes of determining
275 whether it is a redeclaration (following the rules used when determining
276 whether a C++ template specialization is ODR-equivalent), but is not part of
279 The enable_if expression is evaluated as if it were the body of a
280 bool-returning constexpr function declared with the arguments of the function
281 it is being applied to, then called with the parameters at the call site. If the
282 result is false or could not be determined through constant expression
283 evaluation, then this overload will not be chosen and the provided string may
284 be used in a diagnostic if the compile fails as a result.
286 Because the enable_if expression is an unevaluated context, there are no global
287 state changes, nor the ability to pass information from the enable_if
288 expression to the function body. For example, suppose we want calls to
289 strnlen(strbuf, maxlen) to resolve to strnlen_chk(strbuf, maxlen, size of
290 strbuf) only if the size of strbuf can be determined:
294 __attribute__((always_inline))
295 static inline size_t strnlen(const char *s, size_t maxlen)
296 __attribute__((overloadable))
297 __attribute__((enable_if(__builtin_object_size(s, 0) != -1))),
298 "chosen when the buffer size is known but 'maxlen' is not")))
300 return strnlen_chk(s, maxlen, __builtin_object_size(s, 0));
303 Multiple enable_if attributes may be applied to a single declaration. In this
304 case, the enable_if expressions are evaluated from left to right in the
305 following manner. First, the candidates whose enable_if expressions evaluate to
306 false or cannot be evaluated are discarded. If the remaining candidates do not
307 share ODR-equivalent enable_if expressions, the overload resolution is
308 ambiguous. Otherwise, enable_if overload resolution continues with the next
309 enable_if attribute on the candidates that have not been discarded and have
310 remaining enable_if attributes. In this way, we pick the most specific
311 overload out of a number of viable overloads using enable_if.
315 void f() __attribute__((enable_if(true, ""))); // #1
316 void f() __attribute__((enable_if(true, ""))) __attribute__((enable_if(true, ""))); // #2
318 void g(int i, int j) __attribute__((enable_if(i, ""))); // #1
319 void g(int i, int j) __attribute__((enable_if(j, ""))) __attribute__((enable_if(true))); // #2
321 In this example, a call to f() is always resolved to #2, as the first enable_if
322 expression is ODR-equivalent for both declarations, but #1 does not have another
323 enable_if expression to continue evaluating, so the next round of evaluation has
324 only a single candidate. In a call to g(1, 1), the call is ambiguous even though
325 #2 has more enable_if attributes, because the first enable_if expressions are
328 Query for this feature with ``__has_attribute(enable_if)``.
330 Note that functions with one or more ``enable_if`` attributes may not have
331 their address taken, unless all of the conditions specified by said
332 ``enable_if`` are constants that evaluate to ``true``. For example:
336 const int TrueConstant = 1;
337 const int FalseConstant = 0;
338 int f(int a) __attribute__((enable_if(a > 0, "")));
339 int g(int a) __attribute__((enable_if(a == 0 || a != 0, "")));
340 int h(int a) __attribute__((enable_if(1, "")));
341 int i(int a) __attribute__((enable_if(TrueConstant, "")));
342 int j(int a) __attribute__((enable_if(FalseConstant, "")));
346 ptr = &f; // error: 'a > 0' is not always true
347 ptr = &g; // error: 'a == 0 || a != 0' is not a truthy constant
348 ptr = &h; // OK: 1 is a truthy constant
349 ptr = &i; // OK: 'TrueConstant' is a truthy constant
350 ptr = &j; // error: 'FalseConstant' is a constant, but not truthy
353 Because ``enable_if`` evaluation happens during overload resolution,
354 ``enable_if`` may give unintuitive results when used with templates, depending
355 on when overloads are resolved. In the example below, clang will emit a
356 diagnostic about no viable overloads for ``foo`` in ``bar``, but not in ``baz``:
360 double foo(int i) __attribute__((enable_if(i > 0, "")));
361 void *foo(int i) __attribute__((enable_if(i <= 0, "")));
363 auto bar() { return foo(I); }
365 template <typename T>
366 auto baz() { return foo(T::number); }
368 struct WithNumber { constexpr static int number = 1; };
370 bar<sizeof(WithNumber)>();
374 This is because, in ``bar``, ``foo`` is resolved prior to template
375 instantiation, so the value for ``I`` isn't known (thus, both ``enable_if``
376 conditions for ``foo`` fail). However, in ``baz``, ``foo`` is resolved during
377 template instantiation, so the value for ``T::number`` is known.
381 def PassObjectSizeDocs : Documentation {
382 let Category = DocCatVariable; // Technically it's a parameter doc, but eh.
384 .. Note:: The mangling of functions with parameters that are annotated with
385 ``pass_object_size`` is subject to change. You can get around this by
386 using ``__asm__("foo")`` to explicitly name your functions, thus preserving
387 your ABI; also, non-overloadable C functions with ``pass_object_size`` are
390 The ``pass_object_size(Type)`` attribute can be placed on function parameters to
391 instruct clang to call ``__builtin_object_size(param, Type)`` at each callsite
392 of said function, and implicitly pass the result of this call in as an invisible
393 argument of type ``size_t`` directly after the parameter annotated with
394 ``pass_object_size``. Clang will also replace any calls to
395 ``__builtin_object_size(param, Type)`` in the function by said implicit
402 int bzero1(char *const p __attribute__((pass_object_size(0))))
403 __attribute__((noinline)) {
405 for (/**/; i < (int)__builtin_object_size(p, 0); ++i) {
413 int n = bzero1(&chars[0]);
414 assert(n == sizeof(chars));
418 If successfully evaluating ``__builtin_object_size(param, Type)`` at the
419 callsite is not possible, then the "failed" value is passed in. So, using the
420 definition of ``bzero1`` from above, the following code would exit cleanly:
424 int main2(int argc, char *argv[]) {
425 int n = bzero1(argv);
430 ``pass_object_size`` plays a part in overload resolution. If two overload
431 candidates are otherwise equally good, then the overload with one or more
432 parameters with ``pass_object_size`` is preferred. This implies that the choice
433 between two identical overloads both with ``pass_object_size`` on one or more
434 parameters will always be ambiguous; for this reason, having two such overloads
435 is illegal. For example:
439 #define PS(N) __attribute__((pass_object_size(N)))
441 void Foo(char *a, char *b); // Overload A
442 // OK -- overload A has no parameters with pass_object_size.
443 void Foo(char *a PS(0), char *b PS(0)); // Overload B
444 // Error -- Same signature (sans pass_object_size) as overload B, and both
445 // overloads have one or more parameters with the pass_object_size attribute.
446 void Foo(void *a PS(0), void *b);
449 void Bar(void *a PS(0)); // Overload C
451 void Bar(char *c PS(1)); // Overload D
454 char known[10], *unknown;
455 Foo(unknown, unknown); // Calls overload B
456 Foo(known, unknown); // Calls overload B
457 Foo(unknown, known); // Calls overload B
458 Foo(known, known); // Calls overload B
460 Bar(known); // Calls overload D
461 Bar(unknown); // Calls overload D
464 Currently, ``pass_object_size`` is a bit restricted in terms of its usage:
466 * Only one use of ``pass_object_size`` is allowed per parameter.
468 * It is an error to take the address of a function with ``pass_object_size`` on
469 any of its parameters. If you wish to do this, you can create an overload
470 without ``pass_object_size`` on any parameters.
472 * It is an error to apply the ``pass_object_size`` attribute to parameters that
473 are not pointers. Additionally, any parameter that ``pass_object_size`` is
474 applied to must be marked ``const`` at its function's definition.
478 def OverloadableDocs : Documentation {
479 let Category = DocCatFunction;
481 Clang provides support for C++ function overloading in C. Function overloading
482 in C is introduced using the ``overloadable`` attribute. For example, one
483 might provide several overloaded versions of a ``tgsin`` function that invokes
484 the appropriate standard function computing the sine of a value with ``float``,
485 ``double``, or ``long double`` precision:
490 float __attribute__((overloadable)) tgsin(float x) { return sinf(x); }
491 double __attribute__((overloadable)) tgsin(double x) { return sin(x); }
492 long double __attribute__((overloadable)) tgsin(long double x) { return sinl(x); }
494 Given these declarations, one can call ``tgsin`` with a ``float`` value to
495 receive a ``float`` result, with a ``double`` to receive a ``double`` result,
496 etc. Function overloading in C follows the rules of C++ function overloading
497 to pick the best overload given the call arguments, with a few C-specific
500 * Conversion from ``float`` or ``double`` to ``long double`` is ranked as a
501 floating-point promotion (per C99) rather than as a floating-point conversion
504 * A conversion from a pointer of type ``T*`` to a pointer of type ``U*`` is
505 considered a pointer conversion (with conversion rank) if ``T`` and ``U`` are
508 * A conversion from type ``T`` to a value of type ``U`` is permitted if ``T``
509 and ``U`` are compatible types. This conversion is given "conversion" rank.
511 * If no viable candidates are otherwise available, we allow a conversion from a
512 pointer of type ``T*`` to a pointer of type ``U*``, where ``T`` and ``U`` are
513 incompatible. This conversion is ranked below all other types of conversions.
514 Please note: ``U`` lacking qualifiers that are present on ``T`` is sufficient
515 for ``T`` and ``U`` to be incompatible.
517 The declaration of ``overloadable`` functions is restricted to function
518 declarations and definitions. Most importantly, if any function with a given
519 name is given the ``overloadable`` attribute, then all function declarations
520 and definitions with that name (and in that scope) must have the
521 ``overloadable`` attribute. This rule even applies to redeclarations of
522 functions whose original declaration had the ``overloadable`` attribute, e.g.,
526 int f(int) __attribute__((overloadable));
527 float f(float); // error: declaration of "f" must have the "overloadable" attribute
529 int g(int) __attribute__((overloadable));
530 int g(int) { } // error: redeclaration of "g" must also have the "overloadable" attribute
532 Functions marked ``overloadable`` must have prototypes. Therefore, the
533 following code is ill-formed:
537 int h() __attribute__((overloadable)); // error: h does not have a prototype
539 However, ``overloadable`` functions are allowed to use a ellipsis even if there
540 are no named parameters (as is permitted in C++). This feature is particularly
541 useful when combined with the ``unavailable`` attribute:
545 void honeypot(...) __attribute__((overloadable, unavailable)); // calling me is an error
547 Functions declared with the ``overloadable`` attribute have their names mangled
548 according to the same rules as C++ function names. For example, the three
549 ``tgsin`` functions in our motivating example get the mangled names
550 ``_Z5tgsinf``, ``_Z5tgsind``, and ``_Z5tgsine``, respectively. There are two
551 caveats to this use of name mangling:
553 * Future versions of Clang may change the name mangling of functions overloaded
554 in C, so you should not depend on an specific mangling. To be completely
555 safe, we strongly urge the use of ``static inline`` with ``overloadable``
558 * The ``overloadable`` attribute has almost no meaning when used in C++,
559 because names will already be mangled and functions are already overloadable.
560 However, when an ``overloadable`` function occurs within an ``extern "C"``
561 linkage specification, it's name *will* be mangled in the same way as it
564 Query for this feature with ``__has_extension(attribute_overloadable)``.
568 def ObjCMethodFamilyDocs : Documentation {
569 let Category = DocCatFunction;
571 Many methods in Objective-C have conventional meanings determined by their
572 selectors. It is sometimes useful to be able to mark a method as having a
573 particular conventional meaning despite not having the right selector, or as
574 not having the conventional meaning that its selector would suggest. For these
575 use cases, we provide an attribute to specifically describe the "method family"
576 that a method belongs to.
578 **Usage**: ``__attribute__((objc_method_family(X)))``, where ``X`` is one of
579 ``none``, ``alloc``, ``copy``, ``init``, ``mutableCopy``, or ``new``. This
580 attribute can only be placed at the end of a method declaration:
584 - (NSString *)initMyStringValue __attribute__((objc_method_family(none)));
586 Users who do not wish to change the conventional meaning of a method, and who
587 merely want to document its non-standard retain and release semantics, should
588 use the retaining behavior attributes (``ns_returns_retained``,
589 ``ns_returns_not_retained``, etc).
591 Query for this feature with ``__has_attribute(objc_method_family)``.
595 def NoDebugDocs : Documentation {
596 let Category = DocCatVariable;
598 The ``nodebug`` attribute allows you to suppress debugging information for a
599 function or method, or for a variable that is not a parameter or a non-static
604 def NoDuplicateDocs : Documentation {
605 let Category = DocCatFunction;
607 The ``noduplicate`` attribute can be placed on function declarations to control
608 whether function calls to this function can be duplicated or not as a result of
609 optimizations. This is required for the implementation of functions with
610 certain special requirements, like the OpenCL "barrier" function, that might
611 need to be run concurrently by all the threads that are executing in lockstep
612 on the hardware. For example this attribute applied on the function
613 "nodupfunc" in the code below avoids that:
617 void nodupfunc() __attribute__((noduplicate));
618 // Setting it as a C++11 attribute is also valid
619 // void nodupfunc() [[clang::noduplicate]];
630 gets possibly modified by some optimizations into code similar to this:
642 where the call to "nodupfunc" is duplicated and sunk into the two branches
647 def ConvergentDocs : Documentation {
648 let Category = DocCatFunction;
650 The ``convergent`` attribute can be placed on a function declaration. It is
651 translated into the LLVM ``convergent`` attribute, which indicates that the call
652 instructions of a function with this attribute cannot be made control-dependent
653 on any additional values.
655 In languages designed for SPMD/SIMT programming model, e.g. OpenCL or CUDA,
656 the call instructions of a function with this attribute must be executed by
657 all work items or threads in a work group or sub group.
659 This attribute is different from ``noduplicate`` because it allows duplicating
660 function calls if it can be proved that the duplicated function calls are
661 not made control-dependent on any additional values, e.g., unrolling a loop
662 executed by all work items.
667 void convfunc(void) __attribute__((convergent));
668 // Setting it as a C++11 attribute is also valid in a C++ program.
669 // void convfunc(void) [[clang::convergent]];
674 def NoSplitStackDocs : Documentation {
675 let Category = DocCatFunction;
677 The ``no_split_stack`` attribute disables the emission of the split stack
678 preamble for a particular function. It has no effect if ``-fsplit-stack``
683 def ObjCRequiresSuperDocs : Documentation {
684 let Category = DocCatFunction;
686 Some Objective-C classes allow a subclass to override a particular method in a
687 parent class but expect that the overriding method also calls the overridden
688 method in the parent class. For these cases, we provide an attribute to
689 designate that a method requires a "call to ``super``" in the overriding
690 method in the subclass.
692 **Usage**: ``__attribute__((objc_requires_super))``. This attribute can only
693 be placed at the end of a method declaration:
697 - (void)foo __attribute__((objc_requires_super));
699 This attribute can only be applied the method declarations within a class, and
700 not a protocol. Currently this attribute does not enforce any placement of
701 where the call occurs in the overriding method (such as in the case of
702 ``-dealloc`` where the call must appear at the end). It checks only that it
705 Note that on both OS X and iOS that the Foundation framework provides a
706 convenience macro ``NS_REQUIRES_SUPER`` that provides syntactic sugar for this
711 - (void)foo NS_REQUIRES_SUPER;
713 This macro is conditionally defined depending on the compiler's support for
714 this attribute. If the compiler does not support the attribute the macro
717 Operationally, when a method has this annotation the compiler will warn if the
718 implementation of an override in a subclass does not call super. For example:
722 warning: method possibly missing a [super AnnotMeth] call
723 - (void) AnnotMeth{};
728 def ObjCRuntimeNameDocs : Documentation {
729 let Category = DocCatFunction;
731 By default, the Objective-C interface or protocol identifier is used
732 in the metadata name for that object. The `objc_runtime_name`
733 attribute allows annotated interfaces or protocols to use the
734 specified string argument in the object's metadata name instead of the
737 **Usage**: ``__attribute__((objc_runtime_name("MyLocalName")))``. This attribute
738 can only be placed before an @protocol or @interface declaration:
742 __attribute__((objc_runtime_name("MyLocalName")))
749 def ObjCRuntimeVisibleDocs : Documentation {
750 let Category = DocCatFunction;
752 This attribute specifies that the Objective-C class to which it applies is visible to the Objective-C runtime but not to the linker. Classes annotated with this attribute cannot be subclassed and cannot have categories defined for them.
756 def ObjCBoxableDocs : Documentation {
757 let Category = DocCatFunction;
759 Structs and unions marked with the ``objc_boxable`` attribute can be used
760 with the Objective-C boxed expression syntax, ``@(...)``.
762 **Usage**: ``__attribute__((objc_boxable))``. This attribute
763 can only be placed on a declaration of a trivially-copyable struct or union:
767 struct __attribute__((objc_boxable)) some_struct {
770 union __attribute__((objc_boxable)) some_union {
774 typedef struct __attribute__((objc_boxable)) _some_struct some_struct;
779 NSValue *boxed = @(ss);
784 def AvailabilityDocs : Documentation {
785 let Category = DocCatFunction;
787 The ``availability`` attribute can be placed on declarations to describe the
788 lifecycle of that declaration relative to operating system versions. Consider
789 the function declaration for a hypothetical function ``f``:
793 void f(void) __attribute__((availability(macos,introduced=10.4,deprecated=10.6,obsoleted=10.7)));
795 The availability attribute states that ``f`` was introduced in Mac OS X 10.4,
796 deprecated in Mac OS X 10.6, and obsoleted in Mac OS X 10.7. This information
797 is used by Clang to determine when it is safe to use ``f``: for example, if
798 Clang is instructed to compile code for Mac OS X 10.5, a call to ``f()``
799 succeeds. If Clang is instructed to compile code for Mac OS X 10.6, the call
800 succeeds but Clang emits a warning specifying that the function is deprecated.
801 Finally, if Clang is instructed to compile code for Mac OS X 10.7, the call
802 fails because ``f()`` is no longer available.
804 The availability attribute is a comma-separated list starting with the
805 platform name and then including clauses specifying important milestones in the
806 declaration's lifetime (in any order) along with additional information. Those
809 introduced=\ *version*
810 The first version in which this declaration was introduced.
812 deprecated=\ *version*
813 The first version in which this declaration was deprecated, meaning that
814 users should migrate away from this API.
816 obsoleted=\ *version*
817 The first version in which this declaration was obsoleted, meaning that it
818 was removed completely and can no longer be used.
821 This declaration is never available on this platform.
823 message=\ *string-literal*
824 Additional message text that Clang will provide when emitting a warning or
825 error about use of a deprecated or obsoleted declaration. Useful to direct
826 users to replacement APIs.
828 replacement=\ *string-literal*
829 Additional message text that Clang will use to provide Fix-It when emitting
830 a warning about use of a deprecated declaration. The Fix-It will replace
831 the deprecated declaration with the new declaration specified.
833 Multiple availability attributes can be placed on a declaration, which may
834 correspond to different platforms. Only the availability attribute with the
835 platform corresponding to the target platform will be used; any others will be
836 ignored. If no availability attribute specifies availability for the current
837 target platform, the availability attributes are ignored. Supported platforms
841 Apple's iOS operating system. The minimum deployment target is specified by
842 the ``-mios-version-min=*version*`` or ``-miphoneos-version-min=*version*``
843 command-line arguments.
846 Apple's Mac OS X operating system. The minimum deployment target is
847 specified by the ``-mmacosx-version-min=*version*`` command-line argument.
848 ``macosx`` is supported for backward-compatibility reasons, but it is
852 Apple's tvOS operating system. The minimum deployment target is specified by
853 the ``-mtvos-version-min=*version*`` command-line argument.
856 Apple's watchOS operating system. The minimum deployment target is specified by
857 the ``-mwatchos-version-min=*version*`` command-line argument.
859 A declaration can typically be used even when deploying back to a platform
860 version prior to when the declaration was introduced. When this happens, the
861 declaration is `weakly linked
862 <https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html>`_,
863 as if the ``weak_import`` attribute were added to the declaration. A
864 weakly-linked declaration may or may not be present a run-time, and a program
865 can determine whether the declaration is present by checking whether the
866 address of that declaration is non-NULL.
868 The flag ``strict`` disallows using API when deploying back to a
869 platform version prior to when the declaration was introduced. An
870 attempt to use such API before its introduction causes a hard error.
871 Weakly-linking is almost always a better API choice, since it allows
872 users to query availability at runtime.
874 If there are multiple declarations of the same entity, the availability
875 attributes must either match on a per-platform basis or later
876 declarations must not have availability attributes for that
877 platform. For example:
881 void g(void) __attribute__((availability(macos,introduced=10.4)));
882 void g(void) __attribute__((availability(macos,introduced=10.4))); // okay, matches
883 void g(void) __attribute__((availability(ios,introduced=4.0))); // okay, adds a new platform
884 void g(void); // okay, inherits both macos and ios availability from above.
885 void g(void) __attribute__((availability(macos,introduced=10.5))); // error: mismatch
887 When one method overrides another, the overriding method can be more widely available than the overridden method, e.g.,:
892 - (id)method __attribute__((availability(macos,introduced=10.4)));
893 - (id)method2 __attribute__((availability(macos,introduced=10.4)));
897 - (id)method __attribute__((availability(macos,introduced=10.3))); // okay: method moved into base class later
898 - (id)method __attribute__((availability(macos,introduced=10.5))); // error: this method was available via the base class in 10.4
904 def RequireConstantInitDocs : Documentation {
905 let Category = DocCatVariable;
907 This attribute specifies that the variable to which it is attached is intended
908 to have a `constant initializer <http://en.cppreference.com/w/cpp/language/constant_initialization>`_
909 according to the rules of [basic.start.static]. The variable is required to
910 have static or thread storage duration. If the initialization of the variable
911 is not a constant initializer an error will be produced. This attribute may
914 Note that in C++03 strict constant expression checking is not done. Instead
915 the attribute reports if Clang can emit the variable as a constant, even if it's
916 not technically a 'constant initializer'. This behavior is non-portable.
918 Static storage duration variables with constant initializers avoid hard-to-find
919 bugs caused by the indeterminate order of dynamic initialization. They can also
920 be safely used during dynamic initialization across translation units.
922 This attribute acts as a compile time assertion that the requirements
923 for constant initialization have been met. Since these requirements change
924 between dialects and have subtle pitfalls it's important to fail fast instead
925 of silently falling back on dynamic initialization.
930 #define SAFE_STATIC [[clang::require_constant_initialization]]
935 SAFE_STATIC T x = {42}; // Initialization OK. Doesn't check destructor.
936 SAFE_STATIC T y = 42; // error: variable does not have a constant initializer
937 // copy initialization is not a constant expression on a non-literal type.
941 def WarnMaybeUnusedDocs : Documentation {
942 let Category = DocCatVariable;
943 let Heading = "maybe_unused, unused, gnu::unused";
945 When passing the ``-Wunused`` flag to Clang, entities that are unused by the
946 program may be diagnosed. The ``[[maybe_unused]]`` (or
947 ``__attribute__((unused))``) attribute can be used to silence such diagnostics
948 when the entity cannot be removed. For instance, a local variable may exist
949 solely for use in an ``assert()`` statement, which makes the local variable
950 unused when ``NDEBUG`` is defined.
952 The attribute may be applied to the declaration of a class, a typedef, a
953 variable, a function or method, a function parameter, an enumeration, an
954 enumerator, a non-static data member, or a label.
959 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
960 [[maybe_unused]] bool thing2) {
961 [[maybe_unused]] bool b = thing1 && thing2;
967 def WarnUnusedResultsDocs : Documentation {
968 let Category = DocCatFunction;
969 let Heading = "nodiscard, warn_unused_result, clang::warn_unused_result, gnu::warn_unused_result";
971 Clang supports the ability to diagnose when the results of a function call
972 expression are discarded under suspicious circumstances. A diagnostic is
973 generated when a function or its return type is marked with ``[[nodiscard]]``
974 (or ``__attribute__((warn_unused_result))``) and the function call appears as a
975 potentially-evaluated discarded-value expression that is not explicitly cast to
979 struct [[nodiscard]] error_info { /*...*/ };
980 error_info enable_missile_safety_mode();
982 void launch_missiles();
983 void test_missiles() {
984 enable_missile_safety_mode(); // diagnoses
988 void f() { foo(); } // Does not diagnose, error_info is a reference.
992 def FallthroughDocs : Documentation {
993 let Category = DocCatStmt;
994 let Heading = "fallthrough, clang::fallthrough";
996 The ``fallthrough`` (or ``clang::fallthrough``) attribute is used
997 to annotate intentional fall-through
998 between switch labels. It can only be applied to a null statement placed at a
999 point of execution between any statement and the next switch label. It is
1000 common to mark these places with a specific comment, but this attribute is
1001 meant to replace comments with a more strict annotation, which can be checked
1002 by the compiler. This attribute doesn't change semantics of the code and can
1003 be used wherever an intended fall-through occurs. It is designed to mimic
1004 control-flow statements like ``break;``, so it can be placed in most places
1005 where ``break;`` can, but only if there are no statements on the execution path
1006 between it and the next switch label.
1008 By default, Clang does not warn on unannotated fallthrough from one ``switch``
1009 case to another. Diagnostics on fallthrough without a corresponding annotation
1010 can be enabled with the ``-Wimplicit-fallthrough`` argument.
1016 // compile with -Wimplicit-fallthrough
1019 case 33: // no warning: no statements between case labels
1021 case 44: // warning: unannotated fall-through
1023 [[clang::fallthrough]];
1024 case 55: // no warning
1031 [[clang::fallthrough]];
1033 case 66: // no warning
1035 [[clang::fallthrough]]; // warning: fallthrough annotation does not
1036 // directly precede case label
1038 case 77: // warning: unannotated fall-through
1044 def ARMInterruptDocs : Documentation {
1045 let Category = DocCatFunction;
1047 Clang supports the GNU style ``__attribute__((interrupt("TYPE")))`` attribute on
1048 ARM targets. This attribute may be attached to a function definition and
1049 instructs the backend to generate appropriate function entry/exit code so that
1050 it can be used directly as an interrupt service routine.
1052 The parameter passed to the interrupt attribute is optional, but if
1053 provided it must be a string literal with one of the following values: "IRQ",
1054 "FIQ", "SWI", "ABORT", "UNDEF".
1056 The semantics are as follows:
1058 - If the function is AAPCS, Clang instructs the backend to realign the stack to
1059 8 bytes on entry. This is a general requirement of the AAPCS at public
1060 interfaces, but may not hold when an exception is taken. Doing this allows
1061 other AAPCS functions to be called.
1062 - If the CPU is M-class this is all that needs to be done since the architecture
1063 itself is designed in such a way that functions obeying the normal AAPCS ABI
1064 constraints are valid exception handlers.
1065 - If the CPU is not M-class, the prologue and epilogue are modified to save all
1066 non-banked registers that are used, so that upon return the user-mode state
1067 will not be corrupted. Note that to avoid unnecessary overhead, only
1068 general-purpose (integer) registers are saved in this way. If VFP operations
1069 are needed, that state must be saved manually.
1071 Specifically, interrupt kinds other than "FIQ" will save all core registers
1072 except "lr" and "sp". "FIQ" interrupts will save r0-r7.
1073 - If the CPU is not M-class, the return instruction is changed to one of the
1074 canonical sequences permitted by the architecture for exception return. Where
1075 possible the function itself will make the necessary "lr" adjustments so that
1076 the "preferred return address" is selected.
1078 Unfortunately the compiler is unable to make this guarantee for an "UNDEF"
1079 handler, where the offset from "lr" to the preferred return address depends on
1080 the execution state of the code which generated the exception. In this case
1081 a sequence equivalent to "movs pc, lr" will be used.
1085 def MipsInterruptDocs : Documentation {
1086 let Category = DocCatFunction;
1088 Clang supports the GNU style ``__attribute__((interrupt("ARGUMENT")))`` attribute on
1089 MIPS targets. This attribute may be attached to a function definition and instructs
1090 the backend to generate appropriate function entry/exit code so that it can be used
1091 directly as an interrupt service routine.
1093 By default, the compiler will produce a function prologue and epilogue suitable for
1094 an interrupt service routine that handles an External Interrupt Controller (eic)
1095 generated interrupt. This behaviour can be explicitly requested with the "eic"
1098 Otherwise, for use with vectored interrupt mode, the argument passed should be
1099 of the form "vector=LEVEL" where LEVEL is one of the following values:
1100 "sw0", "sw1", "hw0", "hw1", "hw2", "hw3", "hw4", "hw5". The compiler will
1101 then set the interrupt mask to the corresponding level which will mask all
1102 interrupts up to and including the argument.
1104 The semantics are as follows:
1106 - The prologue is modified so that the Exception Program Counter (EPC) and
1107 Status coprocessor registers are saved to the stack. The interrupt mask is
1108 set so that the function can only be interrupted by a higher priority
1109 interrupt. The epilogue will restore the previous values of EPC and Status.
1111 - The prologue and epilogue are modified to save and restore all non-kernel
1112 registers as necessary.
1114 - The FPU is disabled in the prologue, as the floating pointer registers are not
1115 spilled to the stack.
1117 - The function return sequence is changed to use an exception return instruction.
1119 - The parameter sets the interrupt mask for the function corresponding to the
1120 interrupt level specified. If no mask is specified the interrupt mask
1125 def TargetDocs : Documentation {
1126 let Category = DocCatFunction;
1128 Clang supports the GNU style ``__attribute__((target("OPTIONS")))`` attribute.
1129 This attribute may be attached to a function definition and instructs
1130 the backend to use different code generation options than were passed on the
1133 The current set of options correspond to the existing "subtarget features" for
1134 the target with or without a "-mno-" in front corresponding to the absence
1135 of the feature, as well as ``arch="CPU"`` which will change the default "CPU"
1138 Example "subtarget features" from the x86 backend include: "mmx", "sse", "sse4.2",
1139 "avx", "xop" and largely correspond to the machine specific options handled by
1144 def DocCatAMDGPUAttributes : DocumentationCategory<"AMD GPU Attributes">;
1146 def AMDGPUFlatWorkGroupSizeDocs : Documentation {
1147 let Category = DocCatAMDGPUAttributes;
1149 The flat work-group size is the number of work-items in the work-group size
1150 specified when the kernel is dispatched. It is the product of the sizes of the
1151 x, y, and z dimension of the work-group.
1154 ``__attribute__((amdgpu_flat_work_group_size(<min>, <max>)))`` attribute for the
1155 AMDGPU target. This attribute may be attached to a kernel function definition
1156 and is an optimization hint.
1158 ``<min>`` parameter specifies the minimum flat work-group size, and ``<max>``
1159 parameter specifies the maximum flat work-group size (must be greater than
1160 ``<min>``) to which all dispatches of the kernel will conform. Passing ``0, 0``
1161 as ``<min>, <max>`` implies the default behavior (``128, 256``).
1163 If specified, the AMDGPU target backend might be able to produce better machine
1164 code for barriers and perform scratch promotion by estimating available group
1167 An error will be given if:
1168 - Specified values violate subtarget specifications;
1169 - Specified values are not compatible with values provided through other
1174 def AMDGPUWavesPerEUDocs : Documentation {
1175 let Category = DocCatAMDGPUAttributes;
1177 A compute unit (CU) is responsible for executing the wavefronts of a work-group.
1178 It is composed of one or more execution units (EU), which are responsible for
1179 executing the wavefronts. An EU can have enough resources to maintain the state
1180 of more than one executing wavefront. This allows an EU to hide latency by
1181 switching between wavefronts in a similar way to symmetric multithreading on a
1182 CPU. In order to allow the state for multiple wavefronts to fit on an EU, the
1183 resources used by a single wavefront have to be limited. For example, the number
1184 of SGPRs and VGPRs. Limiting such resources can allow greater latency hiding,
1185 but can result in having to spill some register state to memory.
1187 Clang supports the ``__attribute__((amdgpu_waves_per_eu(<min>[, <max>])))``
1188 attribute for the AMDGPU target. This attribute may be attached to a kernel
1189 function definition and is an optimization hint.
1191 ``<min>`` parameter specifies the requested minimum number of waves per EU, and
1192 *optional* ``<max>`` parameter specifies the requested maximum number of waves
1193 per EU (must be greater than ``<min>`` if specified). If ``<max>`` is omitted,
1194 then there is no restriction on the maximum number of waves per EU other than
1195 the one dictated by the hardware for which the kernel is compiled. Passing
1196 ``0, 0`` as ``<min>, <max>`` implies the default behavior (no limits).
1198 If specified, this attribute allows an advanced developer to tune the number of
1199 wavefronts that are capable of fitting within the resources of an EU. The AMDGPU
1200 target backend can use this information to limit resources, such as number of
1201 SGPRs, number of VGPRs, size of available group and private memory segments, in
1202 such a way that guarantees that at least ``<min>`` wavefronts and at most
1203 ``<max>`` wavefronts are able to fit within the resources of an EU. Requesting
1204 more wavefronts can hide memory latency but limits available registers which
1205 can result in spilling. Requesting fewer wavefronts can help reduce cache
1206 thrashing, but can reduce memory latency hiding.
1208 This attribute controls the machine code generated by the AMDGPU target backend
1209 to ensure it is capable of meeting the requested values. However, when the
1210 kernel is executed, there may be other reasons that prevent meeting the request,
1211 for example, there may be wavefronts from other kernels executing on the EU.
1213 An error will be given if:
1214 - Specified values violate subtarget specifications;
1215 - Specified values are not compatible with values provided through other
1217 - The AMDGPU target backend is unable to create machine code that can meet the
1222 def AMDGPUNumSGPRNumVGPRDocs : Documentation {
1223 let Category = DocCatAMDGPUAttributes;
1225 Clang supports the ``__attribute__((amdgpu_num_sgpr(<num_sgpr>)))`` and
1226 ``__attribute__((amdgpu_num_vgpr(<num_vgpr>)))`` attributes for the AMDGPU
1227 target. These attributes may be attached to a kernel function definition and are
1228 an optimization hint.
1230 If these attributes are specified, then the AMDGPU target backend will attempt
1231 to limit the number of SGPRs and/or VGPRs used to the specified value(s). The
1232 number of used SGPRs and/or VGPRs may further be rounded up to satisfy the
1233 allocation requirements or constraints of the subtarget. Passing ``0`` as
1234 ``num_sgpr`` and/or ``num_vgpr`` implies the default behavior (no limits).
1236 These attributes can be used to test the AMDGPU target backend. It is
1237 recommended that the ``amdgpu_waves_per_eu`` attribute be used to control
1238 resources such as SGPRs and VGPRs since it is aware of the limits for different
1241 An error will be given if:
1242 - Specified values violate subtarget specifications;
1243 - Specified values are not compatible with values provided through other
1245 - The AMDGPU target backend is unable to create machine code that can meet the
1250 def DocCatCallingConvs : DocumentationCategory<"Calling Conventions"> {
1252 Clang supports several different calling conventions, depending on the target
1253 platform and architecture. The calling convention used for a function determines
1254 how parameters are passed, how results are returned to the caller, and other
1255 low-level details of calling a function.
1259 def PcsDocs : Documentation {
1260 let Category = DocCatCallingConvs;
1262 On ARM targets, this attribute can be used to select calling conventions
1263 similar to ``stdcall`` on x86. Valid parameter values are "aapcs" and
1268 def RegparmDocs : Documentation {
1269 let Category = DocCatCallingConvs;
1271 On 32-bit x86 targets, the regparm attribute causes the compiler to pass
1272 the first three integer parameters in EAX, EDX, and ECX instead of on the
1273 stack. This attribute has no effect on variadic functions, and all parameters
1274 are passed via the stack as normal.
1278 def SysVABIDocs : Documentation {
1279 let Category = DocCatCallingConvs;
1281 On Windows x86_64 targets, this attribute changes the calling convention of a
1282 function to match the default convention used on Sys V targets such as Linux,
1283 Mac, and BSD. This attribute has no effect on other targets.
1287 def MSABIDocs : Documentation {
1288 let Category = DocCatCallingConvs;
1290 On non-Windows x86_64 targets, this attribute changes the calling convention of
1291 a function to match the default convention used on Windows x86_64. This
1292 attribute has no effect on Windows targets or non-x86_64 targets.
1296 def StdCallDocs : Documentation {
1297 let Category = DocCatCallingConvs;
1299 On 32-bit x86 targets, this attribute changes the calling convention of a
1300 function to clear parameters off of the stack on return. This convention does
1301 not support variadic calls or unprototyped functions in C, and has no effect on
1302 x86_64 targets. This calling convention is used widely by the Windows API and
1303 COM applications. See the documentation for `__stdcall`_ on MSDN.
1305 .. _`__stdcall`: http://msdn.microsoft.com/en-us/library/zxk0tw93.aspx
1309 def FastCallDocs : Documentation {
1310 let Category = DocCatCallingConvs;
1312 On 32-bit x86 targets, this attribute changes the calling convention of a
1313 function to use ECX and EDX as register parameters and clear parameters off of
1314 the stack on return. This convention does not support variadic calls or
1315 unprototyped functions in C, and has no effect on x86_64 targets. This calling
1316 convention is supported primarily for compatibility with existing code. Users
1317 seeking register parameters should use the ``regparm`` attribute, which does
1318 not require callee-cleanup. See the documentation for `__fastcall`_ on MSDN.
1320 .. _`__fastcall`: http://msdn.microsoft.com/en-us/library/6xa169sk.aspx
1324 def RegCallDocs : Documentation {
1325 let Category = DocCatCallingConvs;
1327 On x86 targets, this attribute changes the calling convention to
1328 `__regcall`_ convention. This convention aims to pass as many arguments
1329 as possible in registers. It also tries to utilize registers for the
1330 return value whenever it is possible.
1332 .. _`__regcall`: https://software.intel.com/en-us/node/693069
1336 def ThisCallDocs : Documentation {
1337 let Category = DocCatCallingConvs;
1339 On 32-bit x86 targets, this attribute changes the calling convention of a
1340 function to use ECX for the first parameter (typically the implicit ``this``
1341 parameter of C++ methods) and clear parameters off of the stack on return. This
1342 convention does not support variadic calls or unprototyped functions in C, and
1343 has no effect on x86_64 targets. See the documentation for `__thiscall`_ on
1346 .. _`__thiscall`: http://msdn.microsoft.com/en-us/library/ek8tkfbw.aspx
1350 def VectorCallDocs : Documentation {
1351 let Category = DocCatCallingConvs;
1353 On 32-bit x86 *and* x86_64 targets, this attribute changes the calling
1354 convention of a function to pass vector parameters in SSE registers.
1356 On 32-bit x86 targets, this calling convention is similar to ``__fastcall``.
1357 The first two integer parameters are passed in ECX and EDX. Subsequent integer
1358 parameters are passed in memory, and callee clears the stack. On x86_64
1359 targets, the callee does *not* clear the stack, and integer parameters are
1360 passed in RCX, RDX, R8, and R9 as is done for the default Windows x64 calling
1363 On both 32-bit x86 and x86_64 targets, vector and floating point arguments are
1364 passed in XMM0-XMM5. Homogeneous vector aggregates of up to four elements are
1365 passed in sequential SSE registers if enough are available. If AVX is enabled,
1366 256 bit vectors are passed in YMM0-YMM5. Any vector or aggregate type that
1367 cannot be passed in registers for any reason is passed by reference, which
1368 allows the caller to align the parameter memory.
1370 See the documentation for `__vectorcall`_ on MSDN for more details.
1372 .. _`__vectorcall`: http://msdn.microsoft.com/en-us/library/dn375768.aspx
1376 def DocCatConsumed : DocumentationCategory<"Consumed Annotation Checking"> {
1378 Clang supports additional attributes for checking basic resource management
1379 properties, specifically for unique objects that have a single owning reference.
1380 The following attributes are currently supported, although **the implementation
1381 for these annotations is currently in development and are subject to change.**
1385 def SetTypestateDocs : Documentation {
1386 let Category = DocCatConsumed;
1388 Annotate methods that transition an object into a new state with
1389 ``__attribute__((set_typestate(new_state)))``. The new state must be
1390 unconsumed, consumed, or unknown.
1394 def CallableWhenDocs : Documentation {
1395 let Category = DocCatConsumed;
1397 Use ``__attribute__((callable_when(...)))`` to indicate what states a method
1398 may be called in. Valid states are unconsumed, consumed, or unknown. Each
1399 argument to this attribute must be a quoted string. E.g.:
1401 ``__attribute__((callable_when("unconsumed", "unknown")))``
1405 def TestTypestateDocs : Documentation {
1406 let Category = DocCatConsumed;
1408 Use ``__attribute__((test_typestate(tested_state)))`` to indicate that a method
1409 returns true if the object is in the specified state..
1413 def ParamTypestateDocs : Documentation {
1414 let Category = DocCatConsumed;
1416 This attribute specifies expectations about function parameters. Calls to an
1417 function with annotated parameters will issue a warning if the corresponding
1418 argument isn't in the expected state. The attribute is also used to set the
1419 initial state of the parameter when analyzing the function's body.
1423 def ReturnTypestateDocs : Documentation {
1424 let Category = DocCatConsumed;
1426 The ``return_typestate`` attribute can be applied to functions or parameters.
1427 When applied to a function the attribute specifies the state of the returned
1428 value. The function's body is checked to ensure that it always returns a value
1429 in the specified state. On the caller side, values returned by the annotated
1430 function are initialized to the given state.
1432 When applied to a function parameter it modifies the state of an argument after
1433 a call to the function returns. The function's body is checked to ensure that
1434 the parameter is in the expected state before returning.
1438 def ConsumableDocs : Documentation {
1439 let Category = DocCatConsumed;
1441 Each ``class`` that uses any of the typestate annotations must first be marked
1442 using the ``consumable`` attribute. Failure to do so will result in a warning.
1444 This attribute accepts a single parameter that must be one of the following:
1445 ``unknown``, ``consumed``, or ``unconsumed``.
1449 def NoSanitizeDocs : Documentation {
1450 let Category = DocCatFunction;
1452 Use the ``no_sanitize`` attribute on a function declaration to specify
1453 that a particular instrumentation or set of instrumentations should not be
1454 applied to that function. The attribute takes a list of string literals,
1455 which have the same meaning as values accepted by the ``-fno-sanitize=``
1456 flag. For example, ``__attribute__((no_sanitize("address", "thread")))``
1457 specifies that AddressSanitizer and ThreadSanitizer should not be applied
1460 See :ref:`Controlling Code Generation <controlling-code-generation>` for a
1461 full list of supported sanitizer flags.
1465 def NoSanitizeAddressDocs : Documentation {
1466 let Category = DocCatFunction;
1467 // This function has multiple distinct spellings, and so it requires a custom
1468 // heading to be specified. The most common spelling is sufficient.
1469 let Heading = "no_sanitize_address (no_address_safety_analysis, gnu::no_address_safety_analysis, gnu::no_sanitize_address)";
1471 .. _langext-address_sanitizer:
1473 Use ``__attribute__((no_sanitize_address))`` on a function declaration to
1474 specify that address safety instrumentation (e.g. AddressSanitizer) should
1475 not be applied to that function.
1479 def NoSanitizeThreadDocs : Documentation {
1480 let Category = DocCatFunction;
1481 let Heading = "no_sanitize_thread";
1483 .. _langext-thread_sanitizer:
1485 Use ``__attribute__((no_sanitize_thread))`` on a function declaration to
1486 specify that checks for data races on plain (non-atomic) memory accesses should
1487 not be inserted by ThreadSanitizer. The function is still instrumented by the
1488 tool to avoid false positives and provide meaningful stack traces.
1492 def NoSanitizeMemoryDocs : Documentation {
1493 let Category = DocCatFunction;
1494 let Heading = "no_sanitize_memory";
1496 .. _langext-memory_sanitizer:
1498 Use ``__attribute__((no_sanitize_memory))`` on a function declaration to
1499 specify that checks for uninitialized memory should not be inserted
1500 (e.g. by MemorySanitizer). The function may still be instrumented by the tool
1501 to avoid false positives in other places.
1505 def DocCatTypeSafety : DocumentationCategory<"Type Safety Checking"> {
1507 Clang supports additional attributes to enable checking type safety properties
1508 that can't be enforced by the C type system. To see warnings produced by these
1509 checks, ensure that -Wtype-safety is enabled. Use cases include:
1511 * MPI library implementations, where these attributes enable checking that
1512 the buffer type matches the passed ``MPI_Datatype``;
1513 * for HDF5 library there is a similar use case to MPI;
1514 * checking types of variadic functions' arguments for functions like
1515 ``fcntl()`` and ``ioctl()``.
1517 You can detect support for these attributes with ``__has_attribute()``. For
1522 #if defined(__has_attribute)
1523 # if __has_attribute(argument_with_type_tag) && \
1524 __has_attribute(pointer_with_type_tag) && \
1525 __has_attribute(type_tag_for_datatype)
1526 # define ATTR_MPI_PWT(buffer_idx, type_idx) __attribute__((pointer_with_type_tag(mpi,buffer_idx,type_idx)))
1527 /* ... other macros ... */
1531 #if !defined(ATTR_MPI_PWT)
1532 # define ATTR_MPI_PWT(buffer_idx, type_idx)
1535 int MPI_Send(void *buf, int count, MPI_Datatype datatype /*, other args omitted */)
1540 def ArgumentWithTypeTagDocs : Documentation {
1541 let Category = DocCatTypeSafety;
1542 let Heading = "argument_with_type_tag";
1544 Use ``__attribute__((argument_with_type_tag(arg_kind, arg_idx,
1545 type_tag_idx)))`` on a function declaration to specify that the function
1546 accepts a type tag that determines the type of some other argument.
1548 This attribute is primarily useful for checking arguments of variadic functions
1549 (``pointer_with_type_tag`` can be used in most non-variadic cases).
1551 In the attribute prototype above:
1552 * ``arg_kind`` is an identifier that should be used when annotating all
1553 applicable type tags.
1554 * ``arg_idx`` provides the position of a function argument. The expected type of
1555 this function argument will be determined by the function argument specified
1556 by ``type_tag_idx``. In the code example below, "3" means that the type of the
1557 function's third argument will be determined by ``type_tag_idx``.
1558 * ``type_tag_idx`` provides the position of a function argument. This function
1559 argument will be a type tag. The type tag will determine the expected type of
1560 the argument specified by ``arg_idx``. In the code example below, "2" means
1561 that the type tag associated with the function's second argument should agree
1562 with the type of the argument specified by ``arg_idx``.
1568 int fcntl(int fd, int cmd, ...)
1569 __attribute__(( argument_with_type_tag(fcntl,3,2) ));
1570 // The function's second argument will be a type tag; this type tag will
1571 // determine the expected type of the function's third argument.
1575 def PointerWithTypeTagDocs : Documentation {
1576 let Category = DocCatTypeSafety;
1577 let Heading = "pointer_with_type_tag";
1579 Use ``__attribute__((pointer_with_type_tag(ptr_kind, ptr_idx, type_tag_idx)))``
1580 on a function declaration to specify that the function accepts a type tag that
1581 determines the pointee type of some other pointer argument.
1583 In the attribute prototype above:
1584 * ``ptr_kind`` is an identifier that should be used when annotating all
1585 applicable type tags.
1586 * ``ptr_idx`` provides the position of a function argument; this function
1587 argument will have a pointer type. The expected pointee type of this pointer
1588 type will be determined by the function argument specified by
1589 ``type_tag_idx``. In the code example below, "1" means that the pointee type
1590 of the function's first argument will be determined by ``type_tag_idx``.
1591 * ``type_tag_idx`` provides the position of a function argument; this function
1592 argument will be a type tag. The type tag will determine the expected pointee
1593 type of the pointer argument specified by ``ptr_idx``. In the code example
1594 below, "3" means that the type tag associated with the function's third
1595 argument should agree with the pointee type of the pointer argument specified
1602 typedef int MPI_Datatype;
1603 int MPI_Send(void *buf, int count, MPI_Datatype datatype /*, other args omitted */)
1604 __attribute__(( pointer_with_type_tag(mpi,1,3) ));
1605 // The function's 3rd argument will be a type tag; this type tag will
1606 // determine the expected pointee type of the function's 1st argument.
1610 def TypeTagForDatatypeDocs : Documentation {
1611 let Category = DocCatTypeSafety;
1613 When declaring a variable, use
1614 ``__attribute__((type_tag_for_datatype(kind, type)))`` to create a type tag that
1615 is tied to the ``type`` argument given to the attribute.
1617 In the attribute prototype above:
1618 * ``kind`` is an identifier that should be used when annotating all applicable
1620 * ``type`` indicates the name of the type.
1622 Clang supports annotating type tags of two forms.
1624 * **Type tag that is a reference to a declared identifier.**
1625 Use ``__attribute__((type_tag_for_datatype(kind, type)))`` when declaring that
1630 typedef int MPI_Datatype;
1631 extern struct mpi_datatype mpi_datatype_int
1632 __attribute__(( type_tag_for_datatype(mpi,int) ));
1633 #define MPI_INT ((MPI_Datatype) &mpi_datatype_int)
1634 // &mpi_datatype_int is a type tag. It is tied to type "int".
1636 * **Type tag that is an integral literal.**
1637 Declare a ``static const`` variable with an initializer value and attach
1638 ``__attribute__((type_tag_for_datatype(kind, type)))`` on that declaration:
1642 typedef int MPI_Datatype;
1643 static const MPI_Datatype mpi_datatype_int
1644 __attribute__(( type_tag_for_datatype(mpi,int) )) = 42;
1645 #define MPI_INT ((MPI_Datatype) 42)
1646 // The number 42 is a type tag. It is tied to type "int".
1649 The ``type_tag_for_datatype`` attribute also accepts an optional third argument
1650 that determines how the type of the function argument specified by either
1651 ``arg_idx`` or ``ptr_idx`` is compared against the type associated with the type
1652 tag. (Recall that for the ``argument_with_type_tag`` attribute, the type of the
1653 function argument specified by ``arg_idx`` is compared against the type
1654 associated with the type tag. Also recall that for the ``pointer_with_type_tag``
1655 attribute, the pointee type of the function argument specified by ``ptr_idx`` is
1656 compared against the type associated with the type tag.) There are two supported
1657 values for this optional third argument:
1659 * ``layout_compatible`` will cause types to be compared according to
1660 layout-compatibility rules (In C++11 [class.mem] p 17, 18, see the
1661 layout-compatibility rules for two standard-layout struct types and for two
1662 standard-layout union types). This is useful when creating a type tag
1663 associated with a struct or union type. For example:
1668 typedef int MPI_Datatype;
1669 struct internal_mpi_double_int { double d; int i; };
1670 extern struct mpi_datatype mpi_datatype_double_int
1671 __attribute__(( type_tag_for_datatype(mpi,
1672 struct internal_mpi_double_int, layout_compatible) ));
1674 #define MPI_DOUBLE_INT ((MPI_Datatype) &mpi_datatype_double_int)
1676 int MPI_Send(void *buf, int count, MPI_Datatype datatype, ...)
1677 __attribute__(( pointer_with_type_tag(mpi,1,3) ));
1680 struct my_pair { double a; int b; };
1681 struct my_pair *buffer;
1682 MPI_Send(buffer, 1, MPI_DOUBLE_INT /*, ... */); // no warning because the
1683 // layout of my_pair is
1684 // compatible with that of
1685 // internal_mpi_double_int
1687 struct my_int_pair { int a; int b; }
1688 struct my_int_pair *buffer2;
1689 MPI_Send(buffer2, 1, MPI_DOUBLE_INT /*, ... */); // warning because the
1690 // layout of my_int_pair
1691 // does not match that of
1692 // internal_mpi_double_int
1694 * ``must_be_null`` specifies that the function argument specified by either
1695 ``arg_idx`` (for the ``argument_with_type_tag`` attribute) or ``ptr_idx`` (for
1696 the ``pointer_with_type_tag`` attribute) should be a null pointer constant.
1697 The second argument to the ``type_tag_for_datatype`` attribute is ignored. For
1703 typedef int MPI_Datatype;
1704 extern struct mpi_datatype mpi_datatype_null
1705 __attribute__(( type_tag_for_datatype(mpi, void, must_be_null) ));
1707 #define MPI_DATATYPE_NULL ((MPI_Datatype) &mpi_datatype_null)
1708 int MPI_Send(void *buf, int count, MPI_Datatype datatype, ...)
1709 __attribute__(( pointer_with_type_tag(mpi,1,3) ));
1712 struct my_pair { double a; int b; };
1713 struct my_pair *buffer;
1714 MPI_Send(buffer, 1, MPI_DATATYPE_NULL /*, ... */); // warning: MPI_DATATYPE_NULL
1715 // was specified but buffer
1716 // is not a null pointer
1720 def FlattenDocs : Documentation {
1721 let Category = DocCatFunction;
1723 The ``flatten`` attribute causes calls within the attributed function to
1724 be inlined unless it is impossible to do so, for example if the body of the
1725 callee is unavailable or if the callee has the ``noinline`` attribute.
1729 def FormatDocs : Documentation {
1730 let Category = DocCatFunction;
1733 Clang supports the ``format`` attribute, which indicates that the function
1734 accepts a ``printf`` or ``scanf``-like format string and corresponding
1735 arguments or a ``va_list`` that contains these arguments.
1737 Please see `GCC documentation about format attribute
1738 <http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html>`_ to find details
1739 about attribute syntax.
1741 Clang implements two kinds of checks with this attribute.
1743 #. Clang checks that the function with the ``format`` attribute is called with
1744 a format string that uses format specifiers that are allowed, and that
1745 arguments match the format string. This is the ``-Wformat`` warning, it is
1748 #. Clang checks that the format string argument is a literal string. This is
1749 the ``-Wformat-nonliteral`` warning, it is off by default.
1751 Clang implements this mostly the same way as GCC, but there is a difference
1752 for functions that accept a ``va_list`` argument (for example, ``vprintf``).
1753 GCC does not emit ``-Wformat-nonliteral`` warning for calls to such
1754 functions. Clang does not warn if the format string comes from a function
1755 parameter, where the function is annotated with a compatible attribute,
1756 otherwise it warns. For example:
1760 __attribute__((__format__ (__scanf__, 1, 3)))
1761 void foo(const char* s, char *buf, ...) {
1765 vprintf(s, ap); // warning: format string is not a string literal
1768 In this case we warn because ``s`` contains a format string for a
1769 ``scanf``-like function, but it is passed to a ``printf``-like function.
1771 If the attribute is removed, clang still warns, because the format string is
1772 not a string literal.
1778 __attribute__((__format__ (__printf__, 1, 3)))
1779 void foo(const char* s, char *buf, ...) {
1783 vprintf(s, ap); // warning
1786 In this case Clang does not warn because the format string ``s`` and
1787 the corresponding arguments are annotated. If the arguments are
1788 incorrect, the caller of ``foo`` will receive a warning.
1792 def AlignValueDocs : Documentation {
1793 let Category = DocCatType;
1795 The align_value attribute can be added to the typedef of a pointer type or the
1796 declaration of a variable of pointer or reference type. It specifies that the
1797 pointer will point to, or the reference will bind to, only objects with at
1798 least the provided alignment. This alignment value must be some positive power
1803 typedef double * aligned_double_ptr __attribute__((align_value(64)));
1804 void foo(double & x __attribute__((align_value(128)),
1805 aligned_double_ptr y) { ... }
1807 If the pointer value does not have the specified alignment at runtime, the
1808 behavior of the program is undefined.
1812 def FlagEnumDocs : Documentation {
1813 let Category = DocCatType;
1815 This attribute can be added to an enumerator to signal to the compiler that it
1816 is intended to be used as a flag type. This will cause the compiler to assume
1817 that the range of the type includes all of the values that you can get by
1818 manipulating bits of the enumerator when issuing warnings.
1822 def EmptyBasesDocs : Documentation {
1823 let Category = DocCatType;
1825 The empty_bases attribute permits the compiler to utilize the
1826 empty-base-optimization more frequently.
1827 This attribute only applies to struct, class, and union types.
1828 It is only supported when using the Microsoft C++ ABI.
1832 def LayoutVersionDocs : Documentation {
1833 let Category = DocCatType;
1835 The layout_version attribute requests that the compiler utilize the class
1836 layout rules of a particular compiler version.
1837 This attribute only applies to struct, class, and union types.
1838 It is only supported when using the Microsoft C++ ABI.
1842 def MSInheritanceDocs : Documentation {
1843 let Category = DocCatType;
1844 let Heading = "__single_inhertiance, __multiple_inheritance, __virtual_inheritance";
1846 This collection of keywords is enabled under ``-fms-extensions`` and controls
1847 the pointer-to-member representation used on ``*-*-win32`` targets.
1849 The ``*-*-win32`` targets utilize a pointer-to-member representation which
1850 varies in size and alignment depending on the definition of the underlying
1853 However, this is problematic when a forward declaration is only available and
1854 no definition has been made yet. In such cases, Clang is forced to utilize the
1855 most general representation that is available to it.
1857 These keywords make it possible to use a pointer-to-member representation other
1858 than the most general one regardless of whether or not the definition will ever
1859 be present in the current translation unit.
1861 This family of keywords belong between the ``class-key`` and ``class-name``:
1865 struct __single_inheritance S;
1869 This keyword can be applied to class templates but only has an effect when used
1870 on full specializations:
1874 template <typename T, typename U> struct __single_inheritance A; // warning: inheritance model ignored on primary template
1875 template <typename T> struct __multiple_inheritance A<T, T>; // warning: inheritance model ignored on partial specialization
1876 template <> struct __single_inheritance A<int, float>;
1878 Note that choosing an inheritance model less general than strictly necessary is
1883 struct __multiple_inheritance S; // error: inheritance model does not match definition
1889 def MSNoVTableDocs : Documentation {
1890 let Category = DocCatType;
1892 This attribute can be added to a class declaration or definition to signal to
1893 the compiler that constructors and destructors will not reference the virtual
1894 function table. It is only supported when using the Microsoft C++ ABI.
1898 def OptnoneDocs : Documentation {
1899 let Category = DocCatFunction;
1901 The ``optnone`` attribute suppresses essentially all optimizations
1902 on a function or method, regardless of the optimization level applied to
1903 the compilation unit as a whole. This is particularly useful when you
1904 need to debug a particular function, but it is infeasible to build the
1905 entire application without optimization. Avoiding optimization on the
1906 specified function can improve the quality of the debugging information
1909 This attribute is incompatible with the ``always_inline`` and ``minsize``
1914 def LoopHintDocs : Documentation {
1915 let Category = DocCatStmt;
1916 let Heading = "#pragma clang loop";
1918 The ``#pragma clang loop`` directive allows loop optimization hints to be
1919 specified for the subsequent loop. The directive allows vectorization,
1920 interleaving, and unrolling to be enabled or disabled. Vector width as well
1921 as interleave and unrolling count can be manually specified. See
1922 `language extensions
1923 <http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
1928 def UnrollHintDocs : Documentation {
1929 let Category = DocCatStmt;
1930 let Heading = "#pragma unroll, #pragma nounroll";
1932 Loop unrolling optimization hints can be specified with ``#pragma unroll`` and
1933 ``#pragma nounroll``. The pragma is placed immediately before a for, while,
1934 do-while, or c++11 range-based for loop.
1936 Specifying ``#pragma unroll`` without a parameter directs the loop unroller to
1937 attempt to fully unroll the loop if the trip count is known at compile time and
1938 attempt to partially unroll the loop if the trip count is not known at compile
1948 Specifying the optional parameter, ``#pragma unroll _value_``, directs the
1949 unroller to unroll the loop ``_value_`` times. The parameter may optionally be
1950 enclosed in parentheses:
1964 Specifying ``#pragma nounroll`` indicates that the loop should not be unrolled:
1973 ``#pragma unroll`` and ``#pragma unroll _value_`` have identical semantics to
1974 ``#pragma clang loop unroll(full)`` and
1975 ``#pragma clang loop unroll_count(_value_)`` respectively. ``#pragma nounroll``
1976 is equivalent to ``#pragma clang loop unroll(disable)``. See
1977 `language extensions
1978 <http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
1979 for further details including limitations of the unroll hints.
1983 def OpenCLUnrollHintDocs : Documentation {
1984 let Category = DocCatStmt;
1985 let Heading = "__attribute__((opencl_unroll_hint))";
1987 The opencl_unroll_hint attribute qualifier can be used to specify that a loop
1988 (for, while and do loops) can be unrolled. This attribute qualifier can be
1989 used to specify full unrolling or partial unrolling by a specified amount.
1990 This is a compiler hint and the compiler may ignore this directive. See
1991 `OpenCL v2.0 <https://www.khronos.org/registry/cl/specs/opencl-2.0.pdf>`_
1992 s6.11.5 for details.
1996 def OpenCLAccessDocs : Documentation {
1997 let Category = DocCatStmt;
1998 let Heading = "__read_only, __write_only, __read_write (read_only, write_only, read_write)";
2000 The access qualifiers must be used with image object arguments or pipe arguments
2001 to declare if they are being read or written by a kernel or function.
2003 The read_only/__read_only, write_only/__write_only and read_write/__read_write
2004 names are reserved for use as access qualifiers and shall not be used otherwise.
2009 foo (read_only image2d_t imageA,
2010 write_only image2d_t imageB) {
2014 In the above example imageA is a read-only 2D image object, and imageB is a
2015 write-only 2D image object.
2017 The read_write (or __read_write) qualifier can not be used with pipe.
2019 More details can be found in the OpenCL C language Spec v2.0, Section 6.6.
2023 def DocOpenCLAddressSpaces : DocumentationCategory<"OpenCL Address Spaces"> {
2025 The address space qualifier may be used to specify the region of memory that is
2026 used to allocate the object. OpenCL supports the following address spaces:
2027 __generic(generic), __global(global), __local(local), __private(private),
2028 __constant(constant).
2032 __constant int c = ...;
2034 __generic int* foo(global int* g) {
2041 More details can be found in the OpenCL C language Spec v2.0, Section 6.5.
2045 def OpenCLAddressSpaceGenericDocs : Documentation {
2046 let Category = DocOpenCLAddressSpaces;
2048 The generic address space attribute is only available with OpenCL v2.0 and later.
2049 It can be used with pointer types. Variables in global and local scope and
2050 function parameters in non-kernel functions can have the generic address space
2051 type attribute. It is intended to be a placeholder for any other address space
2052 except for '__constant' in OpenCL code which can be used with multiple address
2057 def OpenCLAddressSpaceConstantDocs : Documentation {
2058 let Category = DocOpenCLAddressSpaces;
2060 The constant address space attribute signals that an object is located in
2061 a constant (non-modifiable) memory region. It is available to all work items.
2062 Any type can be annotated with the constant address space attribute. Objects
2063 with the constant address space qualifier can be declared in any scope and must
2064 have an initializer.
2068 def OpenCLAddressSpaceGlobalDocs : Documentation {
2069 let Category = DocOpenCLAddressSpaces;
2071 The global address space attribute specifies that an object is allocated in
2072 global memory, which is accessible by all work items. The content stored in this
2073 memory area persists between kernel executions. Pointer types to the global
2074 address space are allowed as function parameters or local variables. Starting
2075 with OpenCL v2.0, the global address space can be used with global (program
2076 scope) variables and static local variable as well.
2080 def OpenCLAddressSpaceLocalDocs : Documentation {
2081 let Category = DocOpenCLAddressSpaces;
2083 The local address space specifies that an object is allocated in the local (work
2084 group) memory area, which is accessible to all work items in the same work
2085 group. The content stored in this memory region is not accessible after
2086 the kernel execution ends. In a kernel function scope, any variable can be in
2087 the local address space. In other scopes, only pointer types to the local address
2088 space are allowed. Local address space variables cannot have an initializer.
2092 def OpenCLAddressSpacePrivateDocs : Documentation {
2093 let Category = DocOpenCLAddressSpaces;
2095 The private address space specifies that an object is allocated in the private
2096 (work item) memory. Other work items cannot access the same memory area and its
2097 content is destroyed after work item execution ends. Local variables can be
2098 declared in the private address space. Function arguments are always in the
2099 private address space. Kernel function arguments of a pointer or an array type
2100 cannot point to the private address space.
2104 def OpenCLNoSVMDocs : Documentation {
2105 let Category = DocCatVariable;
2107 OpenCL 2.0 supports the optional ``__attribute__((nosvm))`` qualifier for
2108 pointer variable. It informs the compiler that the pointer does not refer
2109 to a shared virtual memory region. See OpenCL v2.0 s6.7.2 for details.
2111 Since it is not widely used and has been removed from OpenCL 2.1, it is ignored
2115 def NullabilityDocs : DocumentationCategory<"Nullability Attributes"> {
2117 Whether a particular pointer may be "null" is an important concern when working with pointers in the C family of languages. The various nullability attributes indicate whether a particular pointer can be null or not, which makes APIs more expressive and can help static analysis tools identify bugs involving null pointers. Clang supports several kinds of nullability attributes: the ``nonnull`` and ``returns_nonnull`` attributes indicate which function or method parameters and result types can never be null, while nullability type qualifiers indicate which pointer types can be null (``_Nullable``) or cannot be null (``_Nonnull``).
2119 The nullability (type) qualifiers express whether a value of a given pointer type can be null (the ``_Nullable`` qualifier), doesn't have a defined meaning for null (the ``_Nonnull`` qualifier), or for which the purpose of null is unclear (the ``_Null_unspecified`` qualifier). Because nullability qualifiers are expressed within the type system, they are more general than the ``nonnull`` and ``returns_nonnull`` attributes, allowing one to express (for example) a nullable pointer to an array of nonnull pointers. Nullability qualifiers are written to the right of the pointer to which they apply. For example:
2123 // No meaningful result when 'ptr' is null (here, it happens to be undefined behavior).
2124 int fetch(int * _Nonnull ptr) { return *ptr; }
2126 // 'ptr' may be null.
2127 int fetch_or_zero(int * _Nullable ptr) {
2128 return ptr ? *ptr : 0;
2131 // A nullable pointer to non-null pointers to const characters.
2132 const char *join_strings(const char * _Nonnull * _Nullable strings, unsigned n);
2134 In Objective-C, there is an alternate spelling for the nullability qualifiers that can be used in Objective-C methods and properties using context-sensitive, non-underscored keywords. For example:
2136 .. code-block:: objective-c
2138 @interface NSView : NSResponder
2139 - (nullable NSView *)ancestorSharedWithView:(nonnull NSView *)aView;
2140 @property (assign, nullable) NSView *superview;
2141 @property (readonly, nonnull) NSArray *subviews;
2146 def TypeNonNullDocs : Documentation {
2147 let Category = NullabilityDocs;
2149 The ``_Nonnull`` nullability qualifier indicates that null is not a meaningful value for a value of the ``_Nonnull`` pointer type. For example, given a declaration such as:
2153 int fetch(int * _Nonnull ptr);
2155 a caller of ``fetch`` should not provide a null value, and the compiler will produce a warning if it sees a literal null value passed to ``fetch``. Note that, unlike the declaration attribute ``nonnull``, the presence of ``_Nonnull`` does not imply that passing null is undefined behavior: ``fetch`` is free to consider null undefined behavior or (perhaps for backward-compatibility reasons) defensively handle null.
2159 def TypeNullableDocs : Documentation {
2160 let Category = NullabilityDocs;
2162 The ``_Nullable`` nullability qualifier indicates that a value of the ``_Nullable`` pointer type can be null. For example, given:
2166 int fetch_or_zero(int * _Nullable ptr);
2168 a caller of ``fetch_or_zero`` can provide null.
2172 def TypeNullUnspecifiedDocs : Documentation {
2173 let Category = NullabilityDocs;
2175 The ``_Null_unspecified`` nullability qualifier indicates that neither the ``_Nonnull`` nor ``_Nullable`` qualifiers make sense for a particular pointer type. It is used primarily to indicate that the role of null with specific pointers in a nullability-annotated header is unclear, e.g., due to overly-complex implementations or historical factors with a long-lived API.
2179 def NonNullDocs : Documentation {
2180 let Category = NullabilityDocs;
2182 The ``nonnull`` attribute indicates that some function parameters must not be null, and can be used in several different ways. It's original usage (`from GCC <https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes>`_) is as a function (or Objective-C method) attribute that specifies which parameters of the function are nonnull in a comma-separated list. For example:
2186 extern void * my_memcpy (void *dest, const void *src, size_t len)
2187 __attribute__((nonnull (1, 2)));
2189 Here, the ``nonnull`` attribute indicates that parameters 1 and 2
2190 cannot have a null value. Omitting the parenthesized list of parameter indices means that all parameters of pointer type cannot be null:
2194 extern void * my_memcpy (void *dest, const void *src, size_t len)
2195 __attribute__((nonnull));
2197 Clang also allows the ``nonnull`` attribute to be placed directly on a function (or Objective-C method) parameter, eliminating the need to specify the parameter index ahead of type. For example:
2201 extern void * my_memcpy (void *dest __attribute__((nonnull)),
2202 const void *src __attribute__((nonnull)), size_t len);
2204 Note that the ``nonnull`` attribute indicates that passing null to a non-null parameter is undefined behavior, which the optimizer may take advantage of to, e.g., remove null checks. The ``_Nonnull`` type qualifier indicates that a pointer cannot be null in a more general manner (because it is part of the type system) and does not imply undefined behavior, making it more widely applicable.
2208 def ReturnsNonNullDocs : Documentation {
2209 let Category = NullabilityDocs;
2211 The ``returns_nonnull`` attribute indicates that a particular function (or Objective-C method) always returns a non-null pointer. For example, a particular system ``malloc`` might be defined to terminate a process when memory is not available rather than returning a null pointer:
2215 extern void * malloc (size_t size) __attribute__((returns_nonnull));
2217 The ``returns_nonnull`` attribute implies that returning a null pointer is undefined behavior, which the optimizer may take advantage of. The ``_Nonnull`` type qualifier indicates that a pointer cannot be null in a more general manner (because it is part of the type system) and does not imply undefined behavior, making it more widely applicable
2221 def NoAliasDocs : Documentation {
2222 let Category = DocCatFunction;
2224 The ``noalias`` attribute indicates that the only memory accesses inside
2225 function are loads and stores from objects pointed to by its pointer-typed
2226 arguments, with arbitrary offsets.
2230 def OMPDeclareSimdDocs : Documentation {
2231 let Category = DocCatFunction;
2232 let Heading = "#pragma omp declare simd";
2234 The `declare simd` construct can be applied to a function to enable the creation
2235 of one or more versions that can process multiple arguments using SIMD
2236 instructions from a single invocation in a SIMD loop. The `declare simd`
2237 directive is a declarative directive. There may be multiple `declare simd`
2238 directives for a function. The use of a `declare simd` construct on a function
2239 enables the creation of SIMD versions of the associated function that can be
2240 used to process multiple arguments from a single invocation from a SIMD loop
2242 The syntax of the `declare simd` construct is as follows:
2246 #pragma omp declare simd [clause[[,] clause] ...] new-line
2247 [#pragma omp declare simd [clause[[,] clause] ...] new-line]
2249 function definition or declaration
2251 where clause is one of the following:
2256 linear(argument-list[:constant-linear-step])
2257 aligned(argument-list[:alignment])
2258 uniform(argument-list)
2265 def OMPDeclareTargetDocs : Documentation {
2266 let Category = DocCatFunction;
2267 let Heading = "#pragma omp declare target";
2269 The `declare target` directive specifies that variables and functions are mapped
2270 to a device for OpenMP offload mechanism.
2272 The syntax of the declare target directive is as follows:
2276 #pragma omp declare target new-line
2277 declarations-definition-seq
2278 #pragma omp end declare target new-line
2282 def NotTailCalledDocs : Documentation {
2283 let Category = DocCatFunction;
2285 The ``not_tail_called`` attribute prevents tail-call optimization on statically bound calls. It has no effect on indirect calls. Virtual functions, objective-c methods, and functions marked as ``always_inline`` cannot be marked as ``not_tail_called``.
2287 For example, it prevents tail-call optimization in the following case:
2291 int __attribute__((not_tail_called)) foo1(int);
2294 return foo1(a); // No tail-call optimization on direct calls.
2297 However, it doesn't prevent tail-call optimization in this case:
2301 int __attribute__((not_tail_called)) foo1(int);
2304 int (*fn)(int) = &foo1;
2306 // not_tail_called has no effect on an indirect call even if the call can be
2307 // resolved at compile time.
2311 Marking virtual functions as ``not_tail_called`` is an error:
2317 // not_tail_called on a virtual function is an error.
2318 [[clang::not_tail_called]] virtual int foo1();
2322 // Non-virtual functions can be marked ``not_tail_called``.
2323 [[clang::not_tail_called]] int foo3();
2326 class Derived1 : public Base {
2328 int foo1() override;
2330 // not_tail_called on a virtual function is an error.
2331 [[clang::not_tail_called]] int foo2() override;
2336 def InternalLinkageDocs : Documentation {
2337 let Category = DocCatFunction;
2339 The ``internal_linkage`` attribute changes the linkage type of the declaration to internal.
2340 This is similar to C-style ``static``, but can be used on classes and class methods. When applied to a class definition,
2341 this attribute affects all methods and static data members of that class.
2342 This can be used to contain the ABI of a C++ library by excluding unwanted class methods from the export tables.
2346 def DisableTailCallsDocs : Documentation {
2347 let Category = DocCatFunction;
2349 The ``disable_tail_calls`` attribute instructs the backend to not perform tail call optimization inside the marked function.
2357 int foo(int a) __attribute__((disable_tail_calls)) {
2358 return callee(a); // This call is not tail-call optimized.
2361 Marking virtual functions as ``disable_tail_calls`` is legal.
2369 [[clang::disable_tail_calls]] virtual int foo1() {
2370 return callee(); // This call is not tail-call optimized.
2374 class Derived1 : public Base {
2376 int foo1() override {
2377 return callee(); // This call is tail-call optimized.
2384 def AnyX86InterruptDocs : Documentation {
2385 let Category = DocCatFunction;
2387 Clang supports the GNU style ``__attribute__((interrupt))`` attribute on
2388 x86/x86-64 targets.The compiler generates function entry and exit sequences
2389 suitable for use in an interrupt handler when this attribute is present.
2390 The 'IRET' instruction, instead of the 'RET' instruction, is used to return
2391 from interrupt or exception handlers. All registers, except for the EFLAGS
2392 register which is restored by the 'IRET' instruction, are preserved by the
2395 Any interruptible-without-stack-switch code must be compiled with
2396 -mno-red-zone since interrupt handlers can and will, because of the
2397 hardware design, touch the red zone.
2399 1. interrupt handler must be declared with a mandatory pointer argument:
2403 struct interrupt_frame
2412 __attribute__ ((interrupt))
2413 void f (struct interrupt_frame *frame) {
2417 2. exception handler:
2419 The exception handler is very similar to the interrupt handler with
2420 a different mandatory function signature:
2424 __attribute__ ((interrupt))
2425 void f (struct interrupt_frame *frame, uword_t error_code) {
2429 and compiler pops 'ERROR_CODE' off stack before the 'IRET' instruction.
2431 The exception handler should only be used for exceptions which push an
2432 error code and all other exceptions must use the interrupt handler.
2433 The system will crash if the wrong handler is used.
2437 def SwiftCallDocs : Documentation {
2438 let Category = DocCatVariable;
2440 The ``swiftcall`` attribute indicates that a function should be called
2441 using the Swift calling convention for a function or function pointer.
2443 The lowering for the Swift calling convention, as described by the Swift
2444 ABI documentation, occurs in multiple phases. The first, "high-level"
2445 phase breaks down the formal parameters and results into innately direct
2446 and indirect components, adds implicit paraameters for the generic
2447 signature, and assigns the context and error ABI treatments to parameters
2448 where applicable. The second phase breaks down the direct parameters
2449 and results from the first phase and assigns them to registers or the
2450 stack. The ``swiftcall`` convention only handles this second phase of
2451 lowering; the C function type must accurately reflect the results
2452 of the first phase, as follows:
2454 - Results classified as indirect by high-level lowering should be
2455 represented as parameters with the ``swift_indirect_result`` attribute.
2457 - Results classified as direct by high-level lowering should be represented
2460 - First, remove any empty direct results.
2462 - If there are no direct results, the C result type should be ``void``.
2464 - If there is one direct result, the C result type should be a type with
2465 the exact layout of that result type.
2467 - If there are a multiple direct results, the C result type should be
2468 a struct type with the exact layout of a tuple of those results.
2470 - Parameters classified as indirect by high-level lowering should be
2471 represented as parameters of pointer type.
2473 - Parameters classified as direct by high-level lowering should be
2474 omitted if they are empty types; otherwise, they should be represented
2475 as a parameter type with a layout exactly matching the layout of the
2476 Swift parameter type.
2478 - The context parameter, if present, should be represented as a trailing
2479 parameter with the ``swift_context`` attribute.
2481 - The error result parameter, if present, should be represented as a
2482 trailing parameter (always following a context parameter) with the
2483 ``swift_error_result`` attribute.
2485 ``swiftcall`` does not support variadic arguments or unprototyped functions.
2487 The parameter ABI treatment attributes are aspects of the function type.
2488 A function type which which applies an ABI treatment attribute to a
2489 parameter is a different type from an otherwise-identical function type
2490 that does not. A single parameter may not have multiple ABI treatment
2493 Support for this feature is target-dependent, although it should be
2494 supported on every target that Swift supports. Query for this support
2495 with ``__has_attribute(swiftcall)``. This implies support for the
2496 ``swift_context``, ``swift_error_result``, and ``swift_indirect_result``
2501 def SwiftContextDocs : Documentation {
2502 let Category = DocCatVariable;
2504 The ``swift_context`` attribute marks a parameter of a ``swiftcall``
2505 function as having the special context-parameter ABI treatment.
2507 This treatment generally passes the context value in a special register
2508 which is normally callee-preserved.
2510 A ``swift_context`` parameter must either be the last parameter or must be
2511 followed by a ``swift_error_result`` parameter (which itself must always be
2512 the last parameter).
2514 A context parameter must have pointer or reference type.
2518 def SwiftErrorResultDocs : Documentation {
2519 let Category = DocCatVariable;
2521 The ``swift_error_result`` attribute marks a parameter of a ``swiftcall``
2522 function as having the special error-result ABI treatment.
2524 This treatment generally passes the underlying error value in and out of
2525 the function through a special register which is normally callee-preserved.
2526 This is modeled in C by pretending that the register is addressable memory:
2528 - The caller appears to pass the address of a variable of pointer type.
2529 The current value of this variable is copied into the register before
2530 the call; if the call returns normally, the value is copied back into the
2533 - The callee appears to receive the address of a variable. This address
2534 is actually a hidden location in its own stack, initialized with the
2535 value of the register upon entry. When the function returns normally,
2536 the value in that hidden location is written back to the register.
2538 A ``swift_error_result`` parameter must be the last parameter, and it must be
2539 preceded by a ``swift_context`` parameter.
2541 A ``swift_error_result`` parameter must have type ``T**`` or ``T*&`` for some
2542 type T. Note that no qualifiers are permitted on the intermediate level.
2544 It is undefined behavior if the caller does not pass a pointer or
2545 reference to a valid object.
2547 The standard convention is that the error value itself (that is, the
2548 value stored in the apparent argument) will be null upon function entry,
2549 but this is not enforced by the ABI.
2553 def SwiftIndirectResultDocs : Documentation {
2554 let Category = DocCatVariable;
2556 The ``swift_indirect_result`` attribute marks a parameter of a ``swiftcall``
2557 function as having the special indirect-result ABI treatment.
2559 This treatment gives the parameter the target's normal indirect-result
2560 ABI treatment, which may involve passing it differently from an ordinary
2561 parameter. However, only the first indirect result will receive this
2562 treatment. Furthermore, low-level lowering may decide that a direct result
2563 must be returned indirectly; if so, this will take priority over the
2564 ``swift_indirect_result`` parameters.
2566 A ``swift_indirect_result`` parameter must either be the first parameter or
2567 follow another ``swift_indirect_result`` parameter.
2569 A ``swift_indirect_result`` parameter must have type ``T*`` or ``T&`` for
2570 some object type ``T``. If ``T`` is a complete type at the point of
2571 definition of a function, it is undefined behavior if the argument
2572 value does not point to storage of adequate size and alignment for a
2573 value of type ``T``.
2575 Making indirect results explicit in the signature allows C functions to
2576 directly construct objects into them without relying on language
2577 optimizations like C++'s named return value optimization (NRVO).
2581 def AbiTagsDocs : Documentation {
2582 let Category = DocCatFunction;
2584 The ``abi_tag`` attribute can be applied to a function, variable, class or
2585 inline namespace declaration to modify the mangled name of the entity. It gives
2586 the ability to distinguish between different versions of the same entity but
2587 with different ABI versions supported. For example, a newer version of a class
2588 could have a different set of data members and thus have a different size. Using
2589 the ``abi_tag`` attribute, it is possible to have different mangled names for
2590 a global variable of the class type. Therefor, the old code could keep using
2591 the old manged name and the new code will use the new mangled name with tags.
2595 def PreserveMostDocs : Documentation {
2596 let Category = DocCatCallingConvs;
2598 On X86-64 and AArch64 targets, this attribute changes the calling convention of
2599 a function. The ``preserve_most`` calling convention attempts to make the code
2600 in the caller as unintrusive as possible. This convention behaves identically
2601 to the ``C`` calling convention on how arguments and return values are passed,
2602 but it uses a different set of caller/callee-saved registers. This alleviates
2603 the burden of saving and recovering a large register set before and after the
2604 call in the caller. If the arguments are passed in callee-saved registers,
2605 then they will be preserved by the callee across the call. This doesn't
2606 apply for values returned in callee-saved registers.
2608 - On X86-64 the callee preserves all general purpose registers, except for
2609 R11. R11 can be used as a scratch register. Floating-point registers
2610 (XMMs/YMMs) are not preserved and need to be saved by the caller.
2612 The idea behind this convention is to support calls to runtime functions
2613 that have a hot path and a cold path. The hot path is usually a small piece
2614 of code that doesn't use many registers. The cold path might need to call out to
2615 another function and therefore only needs to preserve the caller-saved
2616 registers, which haven't already been saved by the caller. The
2617 `preserve_most` calling convention is very similar to the ``cold`` calling
2618 convention in terms of caller/callee-saved registers, but they are used for
2619 different types of function calls. ``coldcc`` is for function calls that are
2620 rarely executed, whereas `preserve_most` function calls are intended to be
2621 on the hot path and definitely executed a lot. Furthermore ``preserve_most``
2622 doesn't prevent the inliner from inlining the function call.
2624 This calling convention will be used by a future version of the Objective-C
2625 runtime and should therefore still be considered experimental at this time.
2626 Although this convention was created to optimize certain runtime calls to
2627 the Objective-C runtime, it is not limited to this runtime and might be used
2628 by other runtimes in the future too. The current implementation only
2629 supports X86-64 and AArch64, but the intention is to support more architectures
2634 def PreserveAllDocs : Documentation {
2635 let Category = DocCatCallingConvs;
2637 On X86-64 and AArch64 targets, this attribute changes the calling convention of
2638 a function. The ``preserve_all`` calling convention attempts to make the code
2639 in the caller even less intrusive than the ``preserve_most`` calling convention.
2640 This calling convention also behaves identical to the ``C`` calling convention
2641 on how arguments and return values are passed, but it uses a different set of
2642 caller/callee-saved registers. This removes the burden of saving and
2643 recovering a large register set before and after the call in the caller. If
2644 the arguments are passed in callee-saved registers, then they will be
2645 preserved by the callee across the call. This doesn't apply for values
2646 returned in callee-saved registers.
2648 - On X86-64 the callee preserves all general purpose registers, except for
2649 R11. R11 can be used as a scratch register. Furthermore it also preserves
2650 all floating-point registers (XMMs/YMMs).
2652 The idea behind this convention is to support calls to runtime functions
2653 that don't need to call out to any other functions.
2655 This calling convention, like the ``preserve_most`` calling convention, will be
2656 used by a future version of the Objective-C runtime and should be considered
2657 experimental at this time.
2661 def DeprecatedDocs : Documentation {
2662 let Category = DocCatFunction;
2664 The ``deprecated`` attribute can be applied to a function, a variable, or a
2665 type. This is useful when identifying functions, variables, or types that are
2666 expected to be removed in a future version of a program.
2668 Consider the function declaration for a hypothetical function ``f``:
2672 void f(void) __attribute__((deprecated("message", "replacement")));
2674 When spelled as `__attribute__((deprecated))`, the deprecated attribute can have
2675 two optional string arguments. The first one is the message to display when
2676 emitting the warning; the second one enables the compiler to provide a Fix-It
2677 to replace the deprecated name with a new name. Otherwise, when spelled as
2678 `[[gnu::deprecated]] or [[deprecated]]`, the attribute can have one optional
2679 string argument which is the message to display when emitting the warning.
2683 def IFuncDocs : Documentation {
2684 let Category = DocCatFunction;
2686 ``__attribute__((ifunc("resolver")))`` is used to mark that the address of a declaration should be resolved at runtime by calling a resolver function.
2688 The symbol name of the resolver function is given in quotes. A function with this name (after mangling) must be defined in the current translation unit; it may be ``static``. The resolver function should take no arguments and return a pointer.
2690 The ``ifunc`` attribute may only be used on a function declaration. A function declaration with an ``ifunc`` attribute is considered to be a definition of the declared entity. The entity must not have weak linkage; for example, in C++, it cannot be applied to a declaration if a definition at that location would be considered inline.
2692 Not all targets support this attribute. ELF targets support this attribute when using binutils v2.20.1 or higher and glibc v2.11.1 or higher. Non-ELF targets currently do not support this attribute.
2696 def LTOVisibilityDocs : Documentation {
2697 let Category = DocCatType;
2699 See :doc:`LTOVisibility`.
2703 def RenderScriptKernelAttributeDocs : Documentation {
2704 let Category = DocCatFunction;
2706 ``__attribute__((kernel))`` is used to mark a ``kernel`` function in
2709 In RenderScript, ``kernel`` functions are used to express data-parallel
2710 computations. The RenderScript runtime efficiently parallelizes ``kernel``
2711 functions to run on computational resources such as multi-core CPUs and GPUs.
2712 See the RenderScript_ documentation for more information.
2714 .. _RenderScript: https://developer.android.com/guide/topics/renderscript/compute.html
2718 def XRayDocs : Documentation {
2719 let Category = DocCatFunction;
2720 let Heading = "xray_always_instrument (clang::xray_always_instrument), xray_never_instrument (clang::xray_never_instrument)";
2722 ``__attribute__((xray_always_instrument))`` or ``[[clang::xray_always_instrument]]`` is used to mark member functions (in C++), methods (in Objective C), and free functions (in C, C++, and Objective C) to be instrumented with XRay. This will cause the function to always have space at the beginning and exit points to allow for runtime patching.
2724 Conversely, ``__attribute__((xray_never_instrument))`` or ``[[clang::xray_never_instrument]]`` will inhibit the insertion of these instrumentation points.
2726 If a function has neither of these attributes, they become subject to the XRay heuristics used to determine whether a function should be instrumented or otherwise.
2730 def TransparentUnionDocs : Documentation {
2731 let Category = DocCatType;
2733 This attribute can be applied to a union to change the behaviour of calls to
2734 functions that have an argument with a transparent union type. The compiler
2735 behaviour is changed in the following manner:
2737 - A value whose type is any member of the transparent union can be passed as an
2738 argument without the need to cast that value.
2740 - The argument is passed to the function using the calling convention of the
2741 first member of the transparent union. Consequently, all the members of the
2742 transparent union should have the same calling convention as its first member.
2744 Transparent unions are not supported in C++.
2748 def ObjCSubclassingRestrictedDocs : Documentation {
2749 let Category = DocCatType;
2751 This attribute can be added to an Objective-C ``@interface`` declaration to
2752 ensure that this class cannot be subclassed.