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 ThreadDocs : Documentation {
71 let Category = DocCatVariable;
73 The ``__declspec(thread)`` attribute declares a variable with thread local
74 storage. It is available under the ``-fms-extensions`` flag for MSVC
75 compatibility. See the documentation for `__declspec(thread)`_ on MSDN.
77 .. _`__declspec(thread)`: http://msdn.microsoft.com/en-us/library/9w1sdazb.aspx
79 In Clang, ``__declspec(thread)`` is generally equivalent in functionality to the
80 GNU ``__thread`` keyword. The variable must not have a destructor and must have
81 a constant initializer, if any. The attribute only applies to variables
82 declared with static storage duration, such as globals, class static data
83 members, and static locals.
87 def CarriesDependencyDocs : Documentation {
88 let Category = DocCatFunction;
90 The ``carries_dependency`` attribute specifies dependency propagation into and
93 When specified on a function or Objective-C method, the ``carries_dependency``
94 attribute means that the return value carries a dependency out of the function,
95 so that the implementation need not constrain ordering upon return from that
96 function. Implementations of the function and its caller may choose to preserve
97 dependencies instead of emitting memory ordering instructions such as fences.
99 Note, this attribute does not change the meaning of the program, but may result
100 in generation of more efficient code.
104 def C11NoReturnDocs : Documentation {
105 let Category = DocCatFunction;
107 A function declared as ``_Noreturn`` shall not return to its caller. The
108 compiler will generate a diagnostic for a function declared as ``_Noreturn``
109 that appears to be capable of returning to its caller.
113 def CXX11NoReturnDocs : Documentation {
114 let Category = DocCatFunction;
116 A function declared as ``[[noreturn]]`` shall not return to its caller. The
117 compiler will generate a diagnostic for a function declared as ``[[noreturn]]``
118 that appears to be capable of returning to its caller.
122 def AssertCapabilityDocs : Documentation {
123 let Category = DocCatFunction;
124 let Heading = "assert_capability (assert_shared_capability, clang::assert_capability, clang::assert_shared_capability)";
126 Marks a function that dynamically tests whether a capability is held, and halts
127 the program if it is not held.
131 def AcquireCapabilityDocs : Documentation {
132 let Category = DocCatFunction;
133 let Heading = "acquire_capability (acquire_shared_capability, clang::acquire_capability, clang::acquire_shared_capability)";
135 Marks a function as acquiring a capability.
139 def TryAcquireCapabilityDocs : Documentation {
140 let Category = DocCatFunction;
141 let Heading = "try_acquire_capability (try_acquire_shared_capability, clang::try_acquire_capability, clang::try_acquire_shared_capability)";
143 Marks a function that attempts to acquire a capability. This function may fail to
144 actually acquire the capability; they accept a Boolean value determining
145 whether acquiring the capability means success (true), or failing to acquire
146 the capability means success (false).
150 def ReleaseCapabilityDocs : Documentation {
151 let Category = DocCatFunction;
152 let Heading = "release_capability (release_shared_capability, clang::release_capability, clang::release_shared_capability)";
154 Marks a function as releasing a capability.
158 def AssumeAlignedDocs : Documentation {
159 let Category = DocCatFunction;
161 Use ``__attribute__((assume_aligned(<alignment>[,<offset>]))`` on a function
162 declaration to specify that the return value of the function (which must be a
163 pointer type) has the specified offset, in bytes, from an address with the
164 specified alignment. The offset is taken to be zero if omitted.
168 // The returned pointer value has 32-byte alignment.
169 void *a() __attribute__((assume_aligned (32)));
171 // The returned pointer value is 4 bytes greater than an address having
172 // 32-byte alignment.
173 void *b() __attribute__((assume_aligned (32, 4)));
175 Note that this attribute provides information to the compiler regarding a
176 condition that the code already ensures is true. It does not cause the compiler
177 to enforce the provided alignment assumption.
181 def EnableIfDocs : Documentation {
182 let Category = DocCatFunction;
184 .. Note:: Some features of this attribute are experimental. The meaning of
185 multiple enable_if attributes on a single declaration is subject to change in
186 a future version of clang. Also, the ABI is not standardized and the name
187 mangling may change in future versions. To avoid that, use asm labels.
189 The ``enable_if`` attribute can be placed on function declarations to control
190 which overload is selected based on the values of the function's arguments.
191 When combined with the ``overloadable`` attribute, this feature is also
197 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")));
202 isdigit(-10); // results in a compile-time error.
205 The enable_if attribute takes two arguments, the first is an expression written
206 in terms of the function parameters, the second is a string explaining why this
207 overload candidate could not be selected to be displayed in diagnostics. The
208 expression is part of the function signature for the purposes of determining
209 whether it is a redeclaration (following the rules used when determining
210 whether a C++ template specialization is ODR-equivalent), but is not part of
213 The enable_if expression is evaluated as if it were the body of a
214 bool-returning constexpr function declared with the arguments of the function
215 it is being applied to, then called with the parameters at the call site. If the
216 result is false or could not be determined through constant expression
217 evaluation, then this overload will not be chosen and the provided string may
218 be used in a diagnostic if the compile fails as a result.
220 Because the enable_if expression is an unevaluated context, there are no global
221 state changes, nor the ability to pass information from the enable_if
222 expression to the function body. For example, suppose we want calls to
223 strnlen(strbuf, maxlen) to resolve to strnlen_chk(strbuf, maxlen, size of
224 strbuf) only if the size of strbuf can be determined:
228 __attribute__((always_inline))
229 static inline size_t strnlen(const char *s, size_t maxlen)
230 __attribute__((overloadable))
231 __attribute__((enable_if(__builtin_object_size(s, 0) != -1))),
232 "chosen when the buffer size is known but 'maxlen' is not")))
234 return strnlen_chk(s, maxlen, __builtin_object_size(s, 0));
237 Multiple enable_if attributes may be applied to a single declaration. In this
238 case, the enable_if expressions are evaluated from left to right in the
239 following manner. First, the candidates whose enable_if expressions evaluate to
240 false or cannot be evaluated are discarded. If the remaining candidates do not
241 share ODR-equivalent enable_if expressions, the overload resolution is
242 ambiguous. Otherwise, enable_if overload resolution continues with the next
243 enable_if attribute on the candidates that have not been discarded and have
244 remaining enable_if attributes. In this way, we pick the most specific
245 overload out of a number of viable overloads using enable_if.
249 void f() __attribute__((enable_if(true, ""))); // #1
250 void f() __attribute__((enable_if(true, ""))) __attribute__((enable_if(true, ""))); // #2
252 void g(int i, int j) __attribute__((enable_if(i, ""))); // #1
253 void g(int i, int j) __attribute__((enable_if(j, ""))) __attribute__((enable_if(true))); // #2
255 In this example, a call to f() is always resolved to #2, as the first enable_if
256 expression is ODR-equivalent for both declarations, but #1 does not have another
257 enable_if expression to continue evaluating, so the next round of evaluation has
258 only a single candidate. In a call to g(1, 1), the call is ambiguous even though
259 #2 has more enable_if attributes, because the first enable_if expressions are
262 Query for this feature with ``__has_attribute(enable_if)``.
266 def PassObjectSizeDocs : Documentation {
267 let Category = DocCatVariable; // Technically it's a parameter doc, but eh.
269 .. Note:: The mangling of functions with parameters that are annotated with
270 ``pass_object_size`` is subject to change. You can get around this by
271 using ``__asm__("foo")`` to explicitly name your functions, thus preserving
272 your ABI; also, non-overloadable C functions with ``pass_object_size`` are
275 The ``pass_object_size(Type)`` attribute can be placed on function parameters to
276 instruct clang to call ``__builtin_object_size(param, Type)`` at each callsite
277 of said function, and implicitly pass the result of this call in as an invisible
278 argument of type ``size_t`` directly after the parameter annotated with
279 ``pass_object_size``. Clang will also replace any calls to
280 ``__builtin_object_size(param, Type)`` in the function by said implicit
287 int bzero1(char *const p __attribute__((pass_object_size(0))))
288 __attribute__((noinline)) {
290 for (/**/; i < (int)__builtin_object_size(p, 0); ++i) {
298 int n = bzero1(&chars[0]);
299 assert(n == sizeof(chars));
303 If successfully evaluating ``__builtin_object_size(param, Type)`` at the
304 callsite is not possible, then the "failed" value is passed in. So, using the
305 definition of ``bzero1`` from above, the following code would exit cleanly:
309 int main2(int argc, char *argv[]) {
310 int n = bzero1(argv);
315 ``pass_object_size`` plays a part in overload resolution. If two overload
316 candidates are otherwise equally good, then the overload with one or more
317 parameters with ``pass_object_size`` is preferred. This implies that the choice
318 between two identical overloads both with ``pass_object_size`` on one or more
319 parameters will always be ambiguous; for this reason, having two such overloads
320 is illegal. For example:
324 #define PS(N) __attribute__((pass_object_size(N)))
326 void Foo(char *a, char *b); // Overload A
327 // OK -- overload A has no parameters with pass_object_size.
328 void Foo(char *a PS(0), char *b PS(0)); // Overload B
329 // Error -- Same signature (sans pass_object_size) as overload B, and both
330 // overloads have one or more parameters with the pass_object_size attribute.
331 void Foo(void *a PS(0), void *b);
334 void Bar(void *a PS(0)); // Overload C
336 void Bar(char *c PS(1)); // Overload D
339 char known[10], *unknown;
340 Foo(unknown, unknown); // Calls overload B
341 Foo(known, unknown); // Calls overload B
342 Foo(unknown, known); // Calls overload B
343 Foo(known, known); // Calls overload B
345 Bar(known); // Calls overload D
346 Bar(unknown); // Calls overload D
349 Currently, ``pass_object_size`` is a bit restricted in terms of its usage:
351 * Only one use of ``pass_object_size`` is allowed per parameter.
353 * It is an error to take the address of a function with ``pass_object_size`` on
354 any of its parameters. If you wish to do this, you can create an overload
355 without ``pass_object_size`` on any parameters.
357 * It is an error to apply the ``pass_object_size`` attribute to parameters that
358 are not pointers. Additionally, any parameter that ``pass_object_size`` is
359 applied to must be marked ``const`` at its function's definition.
363 def OverloadableDocs : Documentation {
364 let Category = DocCatFunction;
366 Clang provides support for C++ function overloading in C. Function overloading
367 in C is introduced using the ``overloadable`` attribute. For example, one
368 might provide several overloaded versions of a ``tgsin`` function that invokes
369 the appropriate standard function computing the sine of a value with ``float``,
370 ``double``, or ``long double`` precision:
375 float __attribute__((overloadable)) tgsin(float x) { return sinf(x); }
376 double __attribute__((overloadable)) tgsin(double x) { return sin(x); }
377 long double __attribute__((overloadable)) tgsin(long double x) { return sinl(x); }
379 Given these declarations, one can call ``tgsin`` with a ``float`` value to
380 receive a ``float`` result, with a ``double`` to receive a ``double`` result,
381 etc. Function overloading in C follows the rules of C++ function overloading
382 to pick the best overload given the call arguments, with a few C-specific
385 * Conversion from ``float`` or ``double`` to ``long double`` is ranked as a
386 floating-point promotion (per C99) rather than as a floating-point conversion
389 * A conversion from a pointer of type ``T*`` to a pointer of type ``U*`` is
390 considered a pointer conversion (with conversion rank) if ``T`` and ``U`` are
393 * A conversion from type ``T`` to a value of type ``U`` is permitted if ``T``
394 and ``U`` are compatible types. This conversion is given "conversion" rank.
396 The declaration of ``overloadable`` functions is restricted to function
397 declarations and definitions. Most importantly, if any function with a given
398 name is given the ``overloadable`` attribute, then all function declarations
399 and definitions with that name (and in that scope) must have the
400 ``overloadable`` attribute. This rule even applies to redeclarations of
401 functions whose original declaration had the ``overloadable`` attribute, e.g.,
405 int f(int) __attribute__((overloadable));
406 float f(float); // error: declaration of "f" must have the "overloadable" attribute
408 int g(int) __attribute__((overloadable));
409 int g(int) { } // error: redeclaration of "g" must also have the "overloadable" attribute
411 Functions marked ``overloadable`` must have prototypes. Therefore, the
412 following code is ill-formed:
416 int h() __attribute__((overloadable)); // error: h does not have a prototype
418 However, ``overloadable`` functions are allowed to use a ellipsis even if there
419 are no named parameters (as is permitted in C++). This feature is particularly
420 useful when combined with the ``unavailable`` attribute:
424 void honeypot(...) __attribute__((overloadable, unavailable)); // calling me is an error
426 Functions declared with the ``overloadable`` attribute have their names mangled
427 according to the same rules as C++ function names. For example, the three
428 ``tgsin`` functions in our motivating example get the mangled names
429 ``_Z5tgsinf``, ``_Z5tgsind``, and ``_Z5tgsine``, respectively. There are two
430 caveats to this use of name mangling:
432 * Future versions of Clang may change the name mangling of functions overloaded
433 in C, so you should not depend on an specific mangling. To be completely
434 safe, we strongly urge the use of ``static inline`` with ``overloadable``
437 * The ``overloadable`` attribute has almost no meaning when used in C++,
438 because names will already be mangled and functions are already overloadable.
439 However, when an ``overloadable`` function occurs within an ``extern "C"``
440 linkage specification, it's name *will* be mangled in the same way as it
443 Query for this feature with ``__has_extension(attribute_overloadable)``.
447 def ObjCMethodFamilyDocs : Documentation {
448 let Category = DocCatFunction;
450 Many methods in Objective-C have conventional meanings determined by their
451 selectors. It is sometimes useful to be able to mark a method as having a
452 particular conventional meaning despite not having the right selector, or as
453 not having the conventional meaning that its selector would suggest. For these
454 use cases, we provide an attribute to specifically describe the "method family"
455 that a method belongs to.
457 **Usage**: ``__attribute__((objc_method_family(X)))``, where ``X`` is one of
458 ``none``, ``alloc``, ``copy``, ``init``, ``mutableCopy``, or ``new``. This
459 attribute can only be placed at the end of a method declaration:
463 - (NSString *)initMyStringValue __attribute__((objc_method_family(none)));
465 Users who do not wish to change the conventional meaning of a method, and who
466 merely want to document its non-standard retain and release semantics, should
467 use the retaining behavior attributes (``ns_returns_retained``,
468 ``ns_returns_not_retained``, etc).
470 Query for this feature with ``__has_attribute(objc_method_family)``.
474 def NoDuplicateDocs : Documentation {
475 let Category = DocCatFunction;
477 The ``noduplicate`` attribute can be placed on function declarations to control
478 whether function calls to this function can be duplicated or not as a result of
479 optimizations. This is required for the implementation of functions with
480 certain special requirements, like the OpenCL "barrier" function, that might
481 need to be run concurrently by all the threads that are executing in lockstep
482 on the hardware. For example this attribute applied on the function
483 "nodupfunc" in the code below avoids that:
487 void nodupfunc() __attribute__((noduplicate));
488 // Setting it as a C++11 attribute is also valid
489 // void nodupfunc() [[clang::noduplicate]];
500 gets possibly modified by some optimizations into code similar to this:
512 where the call to "nodupfunc" is duplicated and sunk into the two branches
517 def NoSplitStackDocs : Documentation {
518 let Category = DocCatFunction;
520 The ``no_split_stack`` attribute disables the emission of the split stack
521 preamble for a particular function. It has no effect if ``-fsplit-stack``
526 def ObjCRequiresSuperDocs : Documentation {
527 let Category = DocCatFunction;
529 Some Objective-C classes allow a subclass to override a particular method in a
530 parent class but expect that the overriding method also calls the overridden
531 method in the parent class. For these cases, we provide an attribute to
532 designate that a method requires a "call to ``super``" in the overriding
533 method in the subclass.
535 **Usage**: ``__attribute__((objc_requires_super))``. This attribute can only
536 be placed at the end of a method declaration:
540 - (void)foo __attribute__((objc_requires_super));
542 This attribute can only be applied the method declarations within a class, and
543 not a protocol. Currently this attribute does not enforce any placement of
544 where the call occurs in the overriding method (such as in the case of
545 ``-dealloc`` where the call must appear at the end). It checks only that it
548 Note that on both OS X and iOS that the Foundation framework provides a
549 convenience macro ``NS_REQUIRES_SUPER`` that provides syntactic sugar for this
554 - (void)foo NS_REQUIRES_SUPER;
556 This macro is conditionally defined depending on the compiler's support for
557 this attribute. If the compiler does not support the attribute the macro
560 Operationally, when a method has this annotation the compiler will warn if the
561 implementation of an override in a subclass does not call super. For example:
565 warning: method possibly missing a [super AnnotMeth] call
566 - (void) AnnotMeth{};
571 def ObjCRuntimeNameDocs : Documentation {
572 let Category = DocCatFunction;
574 By default, the Objective-C interface or protocol identifier is used
575 in the metadata name for that object. The `objc_runtime_name`
576 attribute allows annotated interfaces or protocols to use the
577 specified string argument in the object's metadata name instead of the
580 **Usage**: ``__attribute__((objc_runtime_name("MyLocalName")))``. This attribute
581 can only be placed before an @protocol or @interface declaration:
585 __attribute__((objc_runtime_name("MyLocalName")))
592 def ObjCBoxableDocs : Documentation {
593 let Category = DocCatFunction;
595 Structs and unions marked with the ``objc_boxable`` attribute can be used
596 with the Objective-C boxed expression syntax, ``@(...)``.
598 **Usage**: ``__attribute__((objc_boxable))``. This attribute
599 can only be placed on a declaration of a trivially-copyable struct or union:
603 struct __attribute__((objc_boxable)) some_struct {
606 union __attribute__((objc_boxable)) some_union {
610 typedef struct __attribute__((objc_boxable)) _some_struct some_struct;
615 NSValue *boxed = @(ss);
620 def AvailabilityDocs : Documentation {
621 let Category = DocCatFunction;
623 The ``availability`` attribute can be placed on declarations to describe the
624 lifecycle of that declaration relative to operating system versions. Consider
625 the function declaration for a hypothetical function ``f``:
629 void f(void) __attribute__((availability(macosx,introduced=10.4,deprecated=10.6,obsoleted=10.7)));
631 The availability attribute states that ``f`` was introduced in Mac OS X 10.4,
632 deprecated in Mac OS X 10.6, and obsoleted in Mac OS X 10.7. This information
633 is used by Clang to determine when it is safe to use ``f``: for example, if
634 Clang is instructed to compile code for Mac OS X 10.5, a call to ``f()``
635 succeeds. If Clang is instructed to compile code for Mac OS X 10.6, the call
636 succeeds but Clang emits a warning specifying that the function is deprecated.
637 Finally, if Clang is instructed to compile code for Mac OS X 10.7, the call
638 fails because ``f()`` is no longer available.
640 The availability attribute is a comma-separated list starting with the
641 platform name and then including clauses specifying important milestones in the
642 declaration's lifetime (in any order) along with additional information. Those
645 introduced=\ *version*
646 The first version in which this declaration was introduced.
648 deprecated=\ *version*
649 The first version in which this declaration was deprecated, meaning that
650 users should migrate away from this API.
652 obsoleted=\ *version*
653 The first version in which this declaration was obsoleted, meaning that it
654 was removed completely and can no longer be used.
657 This declaration is never available on this platform.
659 message=\ *string-literal*
660 Additional message text that Clang will provide when emitting a warning or
661 error about use of a deprecated or obsoleted declaration. Useful to direct
662 users to replacement APIs.
664 Multiple availability attributes can be placed on a declaration, which may
665 correspond to different platforms. Only the availability attribute with the
666 platform corresponding to the target platform will be used; any others will be
667 ignored. If no availability attribute specifies availability for the current
668 target platform, the availability attributes are ignored. Supported platforms
672 Apple's iOS operating system. The minimum deployment target is specified by
673 the ``-mios-version-min=*version*`` or ``-miphoneos-version-min=*version*``
674 command-line arguments.
677 Apple's Mac OS X operating system. The minimum deployment target is
678 specified by the ``-mmacosx-version-min=*version*`` command-line argument.
681 Apple's tvOS operating system. The minimum deployment target is specified by
682 the ``-mtvos-version-min=*version*`` command-line argument.
685 Apple's watchOS operating system. The minimum deployment target is specified by
686 the ``-mwatchos-version-min=*version*`` command-line argument.
688 A declaration can be used even when deploying back to a platform version prior
689 to when the declaration was introduced. When this happens, the declaration is
691 <https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html>`_,
692 as if the ``weak_import`` attribute were added to the declaration. A
693 weakly-linked declaration may or may not be present a run-time, and a program
694 can determine whether the declaration is present by checking whether the
695 address of that declaration is non-NULL.
697 If there are multiple declarations of the same entity, the availability
698 attributes must either match on a per-platform basis or later
699 declarations must not have availability attributes for that
700 platform. For example:
704 void g(void) __attribute__((availability(macosx,introduced=10.4)));
705 void g(void) __attribute__((availability(macosx,introduced=10.4))); // okay, matches
706 void g(void) __attribute__((availability(ios,introduced=4.0))); // okay, adds a new platform
707 void g(void); // okay, inherits both macosx and ios availability from above.
708 void g(void) __attribute__((availability(macosx,introduced=10.5))); // error: mismatch
710 When one method overrides another, the overriding method can be more widely available than the overridden method, e.g.,:
715 - (id)method __attribute__((availability(macosx,introduced=10.4)));
716 - (id)method2 __attribute__((availability(macosx,introduced=10.4)));
720 - (id)method __attribute__((availability(macosx,introduced=10.3))); // okay: method moved into base class later
721 - (id)method __attribute__((availability(macosx,introduced=10.5))); // error: this method was available via the base class in 10.4
726 def FallthroughDocs : Documentation {
727 let Category = DocCatStmt;
729 The ``clang::fallthrough`` attribute is used along with the
730 ``-Wimplicit-fallthrough`` argument to annotate intentional fall-through
731 between switch labels. It can only be applied to a null statement placed at a
732 point of execution between any statement and the next switch label. It is
733 common to mark these places with a specific comment, but this attribute is
734 meant to replace comments with a more strict annotation, which can be checked
735 by the compiler. This attribute doesn't change semantics of the code and can
736 be used wherever an intended fall-through occurs. It is designed to mimic
737 control-flow statements like ``break;``, so it can be placed in most places
738 where ``break;`` can, but only if there are no statements on the execution path
739 between it and the next switch label.
745 // compile with -Wimplicit-fallthrough
748 case 33: // no warning: no statements between case labels
750 case 44: // warning: unannotated fall-through
752 [[clang::fallthrough]];
753 case 55: // no warning
760 [[clang::fallthrough]];
762 case 66: // no warning
764 [[clang::fallthrough]]; // warning: fallthrough annotation does not
765 // directly precede case label
767 case 77: // warning: unannotated fall-through
773 def ARMInterruptDocs : Documentation {
774 let Category = DocCatFunction;
776 Clang supports the GNU style ``__attribute__((interrupt("TYPE")))`` attribute on
777 ARM targets. This attribute may be attached to a function definition and
778 instructs the backend to generate appropriate function entry/exit code so that
779 it can be used directly as an interrupt service routine.
781 The parameter passed to the interrupt attribute is optional, but if
782 provided it must be a string literal with one of the following values: "IRQ",
783 "FIQ", "SWI", "ABORT", "UNDEF".
785 The semantics are as follows:
787 - If the function is AAPCS, Clang instructs the backend to realign the stack to
788 8 bytes on entry. This is a general requirement of the AAPCS at public
789 interfaces, but may not hold when an exception is taken. Doing this allows
790 other AAPCS functions to be called.
791 - If the CPU is M-class this is all that needs to be done since the architecture
792 itself is designed in such a way that functions obeying the normal AAPCS ABI
793 constraints are valid exception handlers.
794 - If the CPU is not M-class, the prologue and epilogue are modified to save all
795 non-banked registers that are used, so that upon return the user-mode state
796 will not be corrupted. Note that to avoid unnecessary overhead, only
797 general-purpose (integer) registers are saved in this way. If VFP operations
798 are needed, that state must be saved manually.
800 Specifically, interrupt kinds other than "FIQ" will save all core registers
801 except "lr" and "sp". "FIQ" interrupts will save r0-r7.
802 - If the CPU is not M-class, the return instruction is changed to one of the
803 canonical sequences permitted by the architecture for exception return. Where
804 possible the function itself will make the necessary "lr" adjustments so that
805 the "preferred return address" is selected.
807 Unfortunately the compiler is unable to make this guarantee for an "UNDEF"
808 handler, where the offset from "lr" to the preferred return address depends on
809 the execution state of the code which generated the exception. In this case
810 a sequence equivalent to "movs pc, lr" will be used.
814 def MipsInterruptDocs : Documentation {
815 let Category = DocCatFunction;
817 Clang supports the GNU style ``__attribute__((interrupt("ARGUMENT")))`` attribute on
818 MIPS targets. This attribute may be attached to a function definition and instructs
819 the backend to generate appropriate function entry/exit code so that it can be used
820 directly as an interrupt service routine.
822 By default, the compiler will produce a function prologue and epilogue suitable for
823 an interrupt service routine that handles an External Interrupt Controller (eic)
824 generated interrupt. This behaviour can be explicitly requested with the "eic"
827 Otherwise, for use with vectored interrupt mode, the argument passed should be
828 of the form "vector=LEVEL" where LEVEL is one of the following values:
829 "sw0", "sw1", "hw0", "hw1", "hw2", "hw3", "hw4", "hw5". The compiler will
830 then set the interrupt mask to the corresponding level which will mask all
831 interrupts up to and including the argument.
833 The semantics are as follows:
835 - The prologue is modified so that the Exception Program Counter (EPC) and
836 Status coprocessor registers are saved to the stack. The interrupt mask is
837 set so that the function can only be interrupted by a higher priority
838 interrupt. The epilogue will restore the previous values of EPC and Status.
840 - The prologue and epilogue are modified to save and restore all non-kernel
841 registers as necessary.
843 - The FPU is disabled in the prologue, as the floating pointer registers are not
844 spilled to the stack.
846 - The function return sequence is changed to use an exception return instruction.
848 - The parameter sets the interrupt mask for the function corresponding to the
849 interrupt level specified. If no mask is specified the interrupt mask
854 def TargetDocs : Documentation {
855 let Category = DocCatFunction;
857 Clang supports the GNU style ``__attribute__((target("OPTIONS")))`` attribute.
858 This attribute may be attached to a function definition and instructs
859 the backend to use different code generation options than were passed on the
862 The current set of options correspond to the existing "subtarget features" for
863 the target with or without a "-mno-" in front corresponding to the absence
864 of the feature, as well as ``arch="CPU"`` which will change the default "CPU"
867 Example "subtarget features" from the x86 backend include: "mmx", "sse", "sse4.2",
868 "avx", "xop" and largely correspond to the machine specific options handled by
873 def DocCatAMDGPURegisterAttributes :
874 DocumentationCategory<"AMD GPU Register Attributes"> {
876 Clang supports attributes for controlling register usage on AMD GPU
877 targets. These attributes may be attached to a kernel function
878 definition and is an optimization hint to the backend for the maximum
879 number of registers to use. This is useful in cases where register
880 limited occupancy is known to be an important factor for the
881 performance for the kernel.
883 The semantics are as follows:
885 - The backend will attempt to limit the number of used registers to
886 the specified value, but the exact number used is not
887 guaranteed. The number used may be rounded up to satisfy the
888 allocation requirements or ABI constraints of the subtarget. For
889 example, on Southern Islands VGPRs may only be allocated in
890 increments of 4, so requesting a limit of 39 VGPRs will really
891 attempt to use up to 40. Requesting more registers than the
892 subtarget supports will truncate to the maximum allowed. The backend
893 may also use fewer registers than requested whenever possible.
895 - 0 implies the default no limit on register usage.
897 - Ignored on older VLIW subtargets which did not have separate scalar
898 and vector registers, R600 through Northern Islands.
904 def AMDGPUNumVGPRDocs : Documentation {
905 let Category = DocCatAMDGPURegisterAttributes;
908 ``__attribute__((amdgpu_num_vgpr(<num_registers>)))`` attribute on AMD
909 Southern Islands GPUs and later for controlling the number of vector
910 registers. A typical value would be between 4 and 256 in increments
915 def AMDGPUNumSGPRDocs : Documentation {
916 let Category = DocCatAMDGPURegisterAttributes;
920 ``__attribute__((amdgpu_num_sgpr(<num_registers>)))`` attribute on AMD
921 Southern Islands GPUs and later for controlling the number of scalar
922 registers. A typical value would be between 8 and 104 in increments of
925 Due to common instruction constraints, an additional 2-4 SGPRs are
926 typically required for internal use depending on features used. This
927 value is a hint for the total number of SGPRs to use, and not the
928 number of user SGPRs, so no special consideration needs to be given
933 def DocCatCallingConvs : DocumentationCategory<"Calling Conventions"> {
935 Clang supports several different calling conventions, depending on the target
936 platform and architecture. The calling convention used for a function determines
937 how parameters are passed, how results are returned to the caller, and other
938 low-level details of calling a function.
942 def PcsDocs : Documentation {
943 let Category = DocCatCallingConvs;
945 On ARM targets, this attribute can be used to select calling conventions
946 similar to ``stdcall`` on x86. Valid parameter values are "aapcs" and
951 def RegparmDocs : Documentation {
952 let Category = DocCatCallingConvs;
954 On 32-bit x86 targets, the regparm attribute causes the compiler to pass
955 the first three integer parameters in EAX, EDX, and ECX instead of on the
956 stack. This attribute has no effect on variadic functions, and all parameters
957 are passed via the stack as normal.
961 def SysVABIDocs : Documentation {
962 let Category = DocCatCallingConvs;
964 On Windows x86_64 targets, this attribute changes the calling convention of a
965 function to match the default convention used on Sys V targets such as Linux,
966 Mac, and BSD. This attribute has no effect on other targets.
970 def MSABIDocs : Documentation {
971 let Category = DocCatCallingConvs;
973 On non-Windows x86_64 targets, this attribute changes the calling convention of
974 a function to match the default convention used on Windows x86_64. This
975 attribute has no effect on Windows targets or non-x86_64 targets.
979 def StdCallDocs : Documentation {
980 let Category = DocCatCallingConvs;
982 On 32-bit x86 targets, this attribute changes the calling convention of a
983 function to clear parameters off of the stack on return. This convention does
984 not support variadic calls or unprototyped functions in C, and has no effect on
985 x86_64 targets. This calling convention is used widely by the Windows API and
986 COM applications. See the documentation for `__stdcall`_ on MSDN.
988 .. _`__stdcall`: http://msdn.microsoft.com/en-us/library/zxk0tw93.aspx
992 def FastCallDocs : Documentation {
993 let Category = DocCatCallingConvs;
995 On 32-bit x86 targets, this attribute changes the calling convention of a
996 function to use ECX and EDX as register parameters and clear parameters off of
997 the stack on return. This convention does not support variadic calls or
998 unprototyped functions in C, and has no effect on x86_64 targets. This calling
999 convention is supported primarily for compatibility with existing code. Users
1000 seeking register parameters should use the ``regparm`` attribute, which does
1001 not require callee-cleanup. See the documentation for `__fastcall`_ on MSDN.
1003 .. _`__fastcall`: http://msdn.microsoft.com/en-us/library/6xa169sk.aspx
1007 def ThisCallDocs : Documentation {
1008 let Category = DocCatCallingConvs;
1010 On 32-bit x86 targets, this attribute changes the calling convention of a
1011 function to use ECX for the first parameter (typically the implicit ``this``
1012 parameter of C++ methods) and clear parameters off of the stack on return. This
1013 convention does not support variadic calls or unprototyped functions in C, and
1014 has no effect on x86_64 targets. See the documentation for `__thiscall`_ on
1017 .. _`__thiscall`: http://msdn.microsoft.com/en-us/library/ek8tkfbw.aspx
1021 def VectorCallDocs : Documentation {
1022 let Category = DocCatCallingConvs;
1024 On 32-bit x86 *and* x86_64 targets, this attribute changes the calling
1025 convention of a function to pass vector parameters in SSE registers.
1027 On 32-bit x86 targets, this calling convention is similar to ``__fastcall``.
1028 The first two integer parameters are passed in ECX and EDX. Subsequent integer
1029 parameters are passed in memory, and callee clears the stack. On x86_64
1030 targets, the callee does *not* clear the stack, and integer parameters are
1031 passed in RCX, RDX, R8, and R9 as is done for the default Windows x64 calling
1034 On both 32-bit x86 and x86_64 targets, vector and floating point arguments are
1035 passed in XMM0-XMM5. Homogenous vector aggregates of up to four elements are
1036 passed in sequential SSE registers if enough are available. If AVX is enabled,
1037 256 bit vectors are passed in YMM0-YMM5. Any vector or aggregate type that
1038 cannot be passed in registers for any reason is passed by reference, which
1039 allows the caller to align the parameter memory.
1041 See the documentation for `__vectorcall`_ on MSDN for more details.
1043 .. _`__vectorcall`: http://msdn.microsoft.com/en-us/library/dn375768.aspx
1047 def DocCatConsumed : DocumentationCategory<"Consumed Annotation Checking"> {
1049 Clang supports additional attributes for checking basic resource management
1050 properties, specifically for unique objects that have a single owning reference.
1051 The following attributes are currently supported, although **the implementation
1052 for these annotations is currently in development and are subject to change.**
1056 def SetTypestateDocs : Documentation {
1057 let Category = DocCatConsumed;
1059 Annotate methods that transition an object into a new state with
1060 ``__attribute__((set_typestate(new_state)))``. The new state must be
1061 unconsumed, consumed, or unknown.
1065 def CallableWhenDocs : Documentation {
1066 let Category = DocCatConsumed;
1068 Use ``__attribute__((callable_when(...)))`` to indicate what states a method
1069 may be called in. Valid states are unconsumed, consumed, or unknown. Each
1070 argument to this attribute must be a quoted string. E.g.:
1072 ``__attribute__((callable_when("unconsumed", "unknown")))``
1076 def TestTypestateDocs : Documentation {
1077 let Category = DocCatConsumed;
1079 Use ``__attribute__((test_typestate(tested_state)))`` to indicate that a method
1080 returns true if the object is in the specified state..
1084 def ParamTypestateDocs : Documentation {
1085 let Category = DocCatConsumed;
1087 This attribute specifies expectations about function parameters. Calls to an
1088 function with annotated parameters will issue a warning if the corresponding
1089 argument isn't in the expected state. The attribute is also used to set the
1090 initial state of the parameter when analyzing the function's body.
1094 def ReturnTypestateDocs : Documentation {
1095 let Category = DocCatConsumed;
1097 The ``return_typestate`` attribute can be applied to functions or parameters.
1098 When applied to a function the attribute specifies the state of the returned
1099 value. The function's body is checked to ensure that it always returns a value
1100 in the specified state. On the caller side, values returned by the annotated
1101 function are initialized to the given state.
1103 When applied to a function parameter it modifies the state of an argument after
1104 a call to the function returns. The function's body is checked to ensure that
1105 the parameter is in the expected state before returning.
1109 def ConsumableDocs : Documentation {
1110 let Category = DocCatConsumed;
1112 Each ``class`` that uses any of the typestate annotations must first be marked
1113 using the ``consumable`` attribute. Failure to do so will result in a warning.
1115 This attribute accepts a single parameter that must be one of the following:
1116 ``unknown``, ``consumed``, or ``unconsumed``.
1120 def NoSanitizeDocs : Documentation {
1121 let Category = DocCatFunction;
1123 Use the ``no_sanitize`` attribute on a function declaration to specify
1124 that a particular instrumentation or set of instrumentations should not be
1125 applied to that function. The attribute takes a list of string literals,
1126 which have the same meaning as values accepted by the ``-fno-sanitize=``
1127 flag. For example, ``__attribute__((no_sanitize("address", "thread")))``
1128 specifies that AddressSanitizer and ThreadSanitizer should not be applied
1131 See :ref:`Controlling Code Generation <controlling-code-generation>` for a
1132 full list of supported sanitizer flags.
1136 def NoSanitizeAddressDocs : Documentation {
1137 let Category = DocCatFunction;
1138 // This function has multiple distinct spellings, and so it requires a custom
1139 // heading to be specified. The most common spelling is sufficient.
1140 let Heading = "no_sanitize_address (no_address_safety_analysis, gnu::no_address_safety_analysis, gnu::no_sanitize_address)";
1142 .. _langext-address_sanitizer:
1144 Use ``__attribute__((no_sanitize_address))`` on a function declaration to
1145 specify that address safety instrumentation (e.g. AddressSanitizer) should
1146 not be applied to that function.
1150 def NoSanitizeThreadDocs : Documentation {
1151 let Category = DocCatFunction;
1152 let Heading = "no_sanitize_thread";
1154 .. _langext-thread_sanitizer:
1156 Use ``__attribute__((no_sanitize_thread))`` on a function declaration to
1157 specify that checks for data races on plain (non-atomic) memory accesses should
1158 not be inserted by ThreadSanitizer. The function is still instrumented by the
1159 tool to avoid false positives and provide meaningful stack traces.
1163 def NoSanitizeMemoryDocs : Documentation {
1164 let Category = DocCatFunction;
1165 let Heading = "no_sanitize_memory";
1167 .. _langext-memory_sanitizer:
1169 Use ``__attribute__((no_sanitize_memory))`` on a function declaration to
1170 specify that checks for uninitialized memory should not be inserted
1171 (e.g. by MemorySanitizer). The function may still be instrumented by the tool
1172 to avoid false positives in other places.
1176 def DocCatTypeSafety : DocumentationCategory<"Type Safety Checking"> {
1178 Clang supports additional attributes to enable checking type safety properties
1179 that can't be enforced by the C type system. Use cases include:
1181 * MPI library implementations, where these attributes enable checking that
1182 the buffer type matches the passed ``MPI_Datatype``;
1183 * for HDF5 library there is a similar use case to MPI;
1184 * checking types of variadic functions' arguments for functions like
1185 ``fcntl()`` and ``ioctl()``.
1187 You can detect support for these attributes with ``__has_attribute()``. For
1192 #if defined(__has_attribute)
1193 # if __has_attribute(argument_with_type_tag) && \
1194 __has_attribute(pointer_with_type_tag) && \
1195 __has_attribute(type_tag_for_datatype)
1196 # define ATTR_MPI_PWT(buffer_idx, type_idx) __attribute__((pointer_with_type_tag(mpi,buffer_idx,type_idx)))
1197 /* ... other macros ... */
1201 #if !defined(ATTR_MPI_PWT)
1202 # define ATTR_MPI_PWT(buffer_idx, type_idx)
1205 int MPI_Send(void *buf, int count, MPI_Datatype datatype /*, other args omitted */)
1210 def ArgumentWithTypeTagDocs : Documentation {
1211 let Category = DocCatTypeSafety;
1212 let Heading = "argument_with_type_tag";
1214 Use ``__attribute__((argument_with_type_tag(arg_kind, arg_idx,
1215 type_tag_idx)))`` on a function declaration to specify that the function
1216 accepts a type tag that determines the type of some other argument.
1217 ``arg_kind`` is an identifier that should be used when annotating all
1218 applicable type tags.
1220 This attribute is primarily useful for checking arguments of variadic functions
1221 (``pointer_with_type_tag`` can be used in most non-variadic cases).
1227 int fcntl(int fd, int cmd, ...)
1228 __attribute__(( argument_with_type_tag(fcntl,3,2) ));
1232 def PointerWithTypeTagDocs : Documentation {
1233 let Category = DocCatTypeSafety;
1234 let Heading = "pointer_with_type_tag";
1236 Use ``__attribute__((pointer_with_type_tag(ptr_kind, ptr_idx, type_tag_idx)))``
1237 on a function declaration to specify that the function accepts a type tag that
1238 determines the pointee type of some other pointer argument.
1244 int MPI_Send(void *buf, int count, MPI_Datatype datatype /*, other args omitted */)
1245 __attribute__(( pointer_with_type_tag(mpi,1,3) ));
1249 def TypeTagForDatatypeDocs : Documentation {
1250 let Category = DocCatTypeSafety;
1252 Clang supports annotating type tags of two forms.
1254 * **Type tag that is an expression containing a reference to some declared
1255 identifier.** Use ``__attribute__((type_tag_for_datatype(kind, type)))`` on a
1256 declaration with that identifier:
1260 extern struct mpi_datatype mpi_datatype_int
1261 __attribute__(( type_tag_for_datatype(mpi,int) ));
1262 #define MPI_INT ((MPI_Datatype) &mpi_datatype_int)
1264 * **Type tag that is an integral literal.** Introduce a ``static const``
1265 variable with a corresponding initializer value and attach
1266 ``__attribute__((type_tag_for_datatype(kind, type)))`` on that declaration,
1271 #define MPI_INT ((MPI_Datatype) 42)
1272 static const MPI_Datatype mpi_datatype_int
1273 __attribute__(( type_tag_for_datatype(mpi,int) )) = 42
1275 The attribute also accepts an optional third argument that determines how the
1276 expression is compared to the type tag. There are two supported flags:
1278 * ``layout_compatible`` will cause types to be compared according to
1279 layout-compatibility rules (C++11 [class.mem] p 17, 18). This is
1280 implemented to support annotating types like ``MPI_DOUBLE_INT``.
1287 struct internal_mpi_double_int { double d; int i; };
1288 extern struct mpi_datatype mpi_datatype_double_int
1289 __attribute__(( type_tag_for_datatype(mpi, struct internal_mpi_double_int, layout_compatible) ));
1291 #define MPI_DOUBLE_INT ((MPI_Datatype) &mpi_datatype_double_int)
1294 struct my_pair { double a; int b; };
1295 struct my_pair *buffer;
1296 MPI_Send(buffer, 1, MPI_DOUBLE_INT /*, ... */); // no warning
1298 struct my_int_pair { int a; int b; }
1299 struct my_int_pair *buffer2;
1300 MPI_Send(buffer2, 1, MPI_DOUBLE_INT /*, ... */); // warning: actual buffer element
1301 // type 'struct my_int_pair'
1302 // doesn't match specified MPI_Datatype
1304 * ``must_be_null`` specifies that the expression should be a null pointer
1305 constant, for example:
1310 extern struct mpi_datatype mpi_datatype_null
1311 __attribute__(( type_tag_for_datatype(mpi, void, must_be_null) ));
1313 #define MPI_DATATYPE_NULL ((MPI_Datatype) &mpi_datatype_null)
1316 MPI_Send(buffer, 1, MPI_DATATYPE_NULL /*, ... */); // warning: MPI_DATATYPE_NULL
1317 // was specified but buffer
1318 // is not a null pointer
1322 def FlattenDocs : Documentation {
1323 let Category = DocCatFunction;
1325 The ``flatten`` attribute causes calls within the attributed function to
1326 be inlined unless it is impossible to do so, for example if the body of the
1327 callee is unavailable or if the callee has the ``noinline`` attribute.
1331 def FormatDocs : Documentation {
1332 let Category = DocCatFunction;
1335 Clang supports the ``format`` attribute, which indicates that the function
1336 accepts a ``printf`` or ``scanf``-like format string and corresponding
1337 arguments or a ``va_list`` that contains these arguments.
1339 Please see `GCC documentation about format attribute
1340 <http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html>`_ to find details
1341 about attribute syntax.
1343 Clang implements two kinds of checks with this attribute.
1345 #. Clang checks that the function with the ``format`` attribute is called with
1346 a format string that uses format specifiers that are allowed, and that
1347 arguments match the format string. This is the ``-Wformat`` warning, it is
1350 #. Clang checks that the format string argument is a literal string. This is
1351 the ``-Wformat-nonliteral`` warning, it is off by default.
1353 Clang implements this mostly the same way as GCC, but there is a difference
1354 for functions that accept a ``va_list`` argument (for example, ``vprintf``).
1355 GCC does not emit ``-Wformat-nonliteral`` warning for calls to such
1356 functions. Clang does not warn if the format string comes from a function
1357 parameter, where the function is annotated with a compatible attribute,
1358 otherwise it warns. For example:
1362 __attribute__((__format__ (__scanf__, 1, 3)))
1363 void foo(const char* s, char *buf, ...) {
1367 vprintf(s, ap); // warning: format string is not a string literal
1370 In this case we warn because ``s`` contains a format string for a
1371 ``scanf``-like function, but it is passed to a ``printf``-like function.
1373 If the attribute is removed, clang still warns, because the format string is
1374 not a string literal.
1380 __attribute__((__format__ (__printf__, 1, 3)))
1381 void foo(const char* s, char *buf, ...) {
1385 vprintf(s, ap); // warning
1388 In this case Clang does not warn because the format string ``s`` and
1389 the corresponding arguments are annotated. If the arguments are
1390 incorrect, the caller of ``foo`` will receive a warning.
1394 def AlignValueDocs : Documentation {
1395 let Category = DocCatType;
1397 The align_value attribute can be added to the typedef of a pointer type or the
1398 declaration of a variable of pointer or reference type. It specifies that the
1399 pointer will point to, or the reference will bind to, only objects with at
1400 least the provided alignment. This alignment value must be some positive power
1405 typedef double * aligned_double_ptr __attribute__((align_value(64)));
1406 void foo(double & x __attribute__((align_value(128)),
1407 aligned_double_ptr y) { ... }
1409 If the pointer value does not have the specified alignment at runtime, the
1410 behavior of the program is undefined.
1414 def FlagEnumDocs : Documentation {
1415 let Category = DocCatType;
1417 This attribute can be added to an enumerator to signal to the compiler that it
1418 is intended to be used as a flag type. This will cause the compiler to assume
1419 that the range of the type includes all of the values that you can get by
1420 manipulating bits of the enumerator when issuing warnings.
1424 def MSInheritanceDocs : Documentation {
1425 let Category = DocCatType;
1426 let Heading = "__single_inhertiance, __multiple_inheritance, __virtual_inheritance";
1428 This collection of keywords is enabled under ``-fms-extensions`` and controls
1429 the pointer-to-member representation used on ``*-*-win32`` targets.
1431 The ``*-*-win32`` targets utilize a pointer-to-member representation which
1432 varies in size and alignment depending on the definition of the underlying
1435 However, this is problematic when a forward declaration is only available and
1436 no definition has been made yet. In such cases, Clang is forced to utilize the
1437 most general representation that is available to it.
1439 These keywords make it possible to use a pointer-to-member representation other
1440 than the most general one regardless of whether or not the definition will ever
1441 be present in the current translation unit.
1443 This family of keywords belong between the ``class-key`` and ``class-name``:
1447 struct __single_inheritance S;
1451 This keyword can be applied to class templates but only has an effect when used
1452 on full specializations:
1456 template <typename T, typename U> struct __single_inheritance A; // warning: inheritance model ignored on primary template
1457 template <typename T> struct __multiple_inheritance A<T, T>; // warning: inheritance model ignored on partial specialization
1458 template <> struct __single_inheritance A<int, float>;
1460 Note that choosing an inheritance model less general than strictly necessary is
1465 struct __multiple_inheritance S; // error: inheritance model does not match definition
1471 def MSNoVTableDocs : Documentation {
1472 let Category = DocCatType;
1474 This attribute can be added to a class declaration or definition to signal to
1475 the compiler that constructors and destructors will not reference the virtual
1476 function table. It is only supported when using the Microsoft C++ ABI.
1480 def OptnoneDocs : Documentation {
1481 let Category = DocCatFunction;
1483 The ``optnone`` attribute suppresses essentially all optimizations
1484 on a function or method, regardless of the optimization level applied to
1485 the compilation unit as a whole. This is particularly useful when you
1486 need to debug a particular function, but it is infeasible to build the
1487 entire application without optimization. Avoiding optimization on the
1488 specified function can improve the quality of the debugging information
1491 This attribute is incompatible with the ``always_inline`` and ``minsize``
1496 def LoopHintDocs : Documentation {
1497 let Category = DocCatStmt;
1498 let Heading = "#pragma clang loop";
1500 The ``#pragma clang loop`` directive allows loop optimization hints to be
1501 specified for the subsequent loop. The directive allows vectorization,
1502 interleaving, and unrolling to be enabled or disabled. Vector width as well
1503 as interleave and unrolling count can be manually specified. See
1504 `language extensions
1505 <http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
1510 def UnrollHintDocs : Documentation {
1511 let Category = DocCatStmt;
1512 let Heading = "#pragma unroll, #pragma nounroll";
1514 Loop unrolling optimization hints can be specified with ``#pragma unroll`` and
1515 ``#pragma nounroll``. The pragma is placed immediately before a for, while,
1516 do-while, or c++11 range-based for loop.
1518 Specifying ``#pragma unroll`` without a parameter directs the loop unroller to
1519 attempt to fully unroll the loop if the trip count is known at compile time and
1520 attempt to partially unroll the loop if the trip count is not known at compile
1530 Specifying the optional parameter, ``#pragma unroll _value_``, directs the
1531 unroller to unroll the loop ``_value_`` times. The parameter may optionally be
1532 enclosed in parentheses:
1546 Specifying ``#pragma nounroll`` indicates that the loop should not be unrolled:
1555 ``#pragma unroll`` and ``#pragma unroll _value_`` have identical semantics to
1556 ``#pragma clang loop unroll(full)`` and
1557 ``#pragma clang loop unroll_count(_value_)`` respectively. ``#pragma nounroll``
1558 is equivalent to ``#pragma clang loop unroll(disable)``. See
1559 `language extensions
1560 <http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
1561 for further details including limitations of the unroll hints.
1565 def DocOpenCLAddressSpaces : DocumentationCategory<"OpenCL Address Spaces"> {
1567 The address space qualifier may be used to specify the region of memory that is
1568 used to allocate the object. OpenCL supports the following address spaces:
1569 __generic(generic), __global(global), __local(local), __private(private),
1570 __constant(constant).
1574 __constant int c = ...;
1576 __generic int* foo(global int* g) {
1583 More details can be found in the OpenCL C language Spec v2.0, Section 6.5.
1587 def OpenCLAddressSpaceGenericDocs : Documentation {
1588 let Category = DocOpenCLAddressSpaces;
1590 The generic address space attribute is only available with OpenCL v2.0 and later.
1591 It can be used with pointer types. Variables in global and local scope and
1592 function parameters in non-kernel functions can have the generic address space
1593 type attribute. It is intended to be a placeholder for any other address space
1594 except for '__constant' in OpenCL code which can be used with multiple address
1599 def OpenCLAddressSpaceConstantDocs : Documentation {
1600 let Category = DocOpenCLAddressSpaces;
1602 The constant address space attribute signals that an object is located in
1603 a constant (non-modifiable) memory region. It is available to all work items.
1604 Any type can be annotated with the constant address space attribute. Objects
1605 with the constant address space qualifier can be declared in any scope and must
1606 have an initializer.
1610 def OpenCLAddressSpaceGlobalDocs : Documentation {
1611 let Category = DocOpenCLAddressSpaces;
1613 The global address space attribute specifies that an object is allocated in
1614 global memory, which is accessible by all work items. The content stored in this
1615 memory area persists between kernel executions. Pointer types to the global
1616 address space are allowed as function parameters or local variables. Starting
1617 with OpenCL v2.0, the global address space can be used with global (program
1618 scope) variables and static local variable as well.
1622 def OpenCLAddressSpaceLocalDocs : Documentation {
1623 let Category = DocOpenCLAddressSpaces;
1625 The local address space specifies that an object is allocated in the local (work
1626 group) memory area, which is accessible to all work items in the same work
1627 group. The content stored in this memory region is not accessible after
1628 the kernel execution ends. In a kernel function scope, any variable can be in
1629 the local address space. In other scopes, only pointer types to the local address
1630 space are allowed. Local address space variables cannot have an initializer.
1634 def OpenCLAddressSpacePrivateDocs : Documentation {
1635 let Category = DocOpenCLAddressSpaces;
1637 The private address space specifies that an object is allocated in the private
1638 (work item) memory. Other work items cannot access the same memory area and its
1639 content is destroyed after work item execution ends. Local variables can be
1640 declared in the private address space. Function arguments are always in the
1641 private address space. Kernel function arguments of a pointer or an array type
1642 cannot point to the private address space.
1646 def NullabilityDocs : DocumentationCategory<"Nullability Attributes"> {
1648 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``).
1650 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:
1654 // No meaningful result when 'ptr' is null (here, it happens to be undefined behavior).
1655 int fetch(int * _Nonnull ptr) { return *ptr; }
1657 // 'ptr' may be null.
1658 int fetch_or_zero(int * _Nullable ptr) {
1659 return ptr ? *ptr : 0;
1662 // A nullable pointer to non-null pointers to const characters.
1663 const char *join_strings(const char * _Nonnull * _Nullable strings, unsigned n);
1665 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:
1667 .. code-block:: objective-c
1669 @interface NSView : NSResponder
1670 - (nullable NSView *)ancestorSharedWithView:(nonnull NSView *)aView;
1671 @property (assign, nullable) NSView *superview;
1672 @property (readonly, nonnull) NSArray *subviews;
1677 def TypeNonNullDocs : Documentation {
1678 let Category = NullabilityDocs;
1680 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:
1684 int fetch(int * _Nonnull ptr);
1686 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.
1690 def TypeNullableDocs : Documentation {
1691 let Category = NullabilityDocs;
1693 The ``_Nullable`` nullability qualifier indicates that a value of the ``_Nullable`` pointer type can be null. For example, given:
1697 int fetch_or_zero(int * _Nullable ptr);
1699 a caller of ``fetch_or_zero`` can provide null.
1703 def TypeNullUnspecifiedDocs : Documentation {
1704 let Category = NullabilityDocs;
1706 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.
1710 def NonNullDocs : Documentation {
1711 let Category = NullabilityDocs;
1713 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:
1717 extern void * my_memcpy (void *dest, const void *src, size_t len)
1718 __attribute__((nonnull (1, 2)));
1720 Here, the ``nonnull`` attribute indicates that parameters 1 and 2
1721 cannot have a null value. Omitting the parenthesized list of parameter indices means that all parameters of pointer type cannot be null:
1725 extern void * my_memcpy (void *dest, const void *src, size_t len)
1726 __attribute__((nonnull));
1728 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:
1732 extern void * my_memcpy (void *dest __attribute__((nonnull)),
1733 const void *src __attribute__((nonnull)), size_t len);
1735 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.
1739 def ReturnsNonNullDocs : Documentation {
1740 let Category = NullabilityDocs;
1742 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:
1746 extern void * malloc (size_t size) __attribute__((returns_nonnull));
1748 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
1752 def NoAliasDocs : Documentation {
1753 let Category = DocCatFunction;
1755 The ``noalias`` attribute indicates that the only memory accesses inside
1756 function are loads and stores from objects pointed to by its pointer-typed
1757 arguments, with arbitrary offsets.
1761 def NotTailCalledDocs : Documentation {
1762 let Category = DocCatFunction;
1764 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``.
1766 For example, it prevents tail-call optimization in the following case:
1770 int __attribute__((not_tail_called)) foo1(int);
1773 return foo1(a); // No tail-call optimization on direct calls.
1776 However, it doesn't prevent tail-call optimization in this case:
1780 int __attribute__((not_tail_called)) foo1(int);
1783 int (*fn)(int) = &foo1;
1785 // not_tail_called has no effect on an indirect call even if the call can be
1786 // resolved at compile time.
1790 Marking virtual functions as ``not_tail_called`` is an error:
1796 // not_tail_called on a virtual function is an error.
1797 [[clang::not_tail_called]] virtual int foo1();
1801 // Non-virtual functions can be marked ``not_tail_called``.
1802 [[clang::not_tail_called]] int foo3();
1805 class Derived1 : public Base {
1807 int foo1() override;
1809 // not_tail_called on a virtual function is an error.
1810 [[clang::not_tail_called]] int foo2() override;
1815 def InternalLinkageDocs : Documentation {
1816 let Category = DocCatFunction;
1818 The ``internal_linkage`` attribute changes the linkage type of the declaration to internal.
1819 This is similar to C-style ``static``, but can be used on classes and class methods. When applied to a class definition,
1820 this attribute affects all methods and static data members of that class.
1821 This can be used to contain the ABI of a C++ library by excluding unwanted class methods from the export tables.
1825 def DisableTailCallsDocs : Documentation {
1826 let Category = DocCatFunction;
1828 The ``disable_tail_calls`` attribute instructs the backend to not perform tail call optimization inside the marked function.
1836 int foo(int a) __attribute__((disable_tail_calls)) {
1837 return callee(a); // This call is not tail-call optimized.
1840 Marking virtual functions as ``disable_tail_calls`` is legal.
1848 [[clang::disable_tail_calls]] virtual int foo1() {
1849 return callee(); // This call is not tail-call optimized.
1853 class Derived1 : public Base {
1855 int foo1() override {
1856 return callee(); // This call is tail-call optimized.