Lines Matching +refs:clang +refs:format +refs:style
50 #define __has_builtin(x) 0 // Compatibility with non-clang compilers.
85 #define __has_feature(x) 0 // Compatibility with non-clang compilers.
128 name of a double-square-bracket-style attribute. The argument can either be a
145 #if __has_cpp_attribute(clang::fallthrough)
146 #define FALLTHROUGH [[clang::fallthrough]]
152 The attribute scope tokens ``clang`` and ``_Clang`` are interchangeable, as are
170 #define __has_c_attribute(x) 0 // Compatibility with non-clang compilers.
181 The attribute scope tokens ``clang`` and ``_Clang`` are interchangeable, as are
191 a GNU-style attribute. It evaluates to 1 if the attribute is supported by the
197 #define __has_attribute(x) 0 // Compatibility with non-clang compilers.
217 an attribute implemented as a Microsoft-style ``__declspec`` attribute. It
224 #define __has_declspec_attribute(x) 0 // Compatibility with non-clang compilers.
251 #ifdef __is_identifier // Compatibility with non-clang compilers.
289 // To avoid problem with non-clang compilers not having this macro.
314 // To avoid problem with non-clang compilers not having this macro.
423 Giving ``-maltivec`` option to clang enables support for AltiVec vector syntax
495 C-style cast yes yes yes no
533 ``__fp16`` is supported on every target, as it is purely a storage format; see below.
544 ``__bf16`` is purely a storage format; it is currently only supported on the following targets:
550 ``__fp16`` is a storage and interchange format only. This means that values of
554 Clang uses the ``binary16`` format from IEEE 754-2008 for ``__fp16``, not the ARM
555 alternative format.
562 format from IEEE 754-2008 for ``_Float16``.
586 certain library facilities with ``_Float16``; for example, there is no ``printf`` format
673 See `the C++ status page <https://clang.llvm.org/cxx_status.html#ts>`_ for
1096 More information could be found `here <https://clang.llvm.org/docs/Modules.html>`_.
1294 the clang implementation are in :doc:`Block-ABI-Apple<Block-ABI-Apple>`.
1302 assembly <https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html>`_, clang
1420 Clang supports ARC-style weak and unsafe references in Objective-C even
1424 unconditionally. ARC-style weak and unsafe references cannot be used
1455 means the ARC-style qualifier in all non-GC modes and is no longer
1552 feature, clang provides default synthesis of those properties not declared
1555 of this feature in version of clang being used.
1568 `static analyzer <https://clang-analyzer.llvm.org>`_ Some exceptions may be
1605 <https://clang-analyzer.llvm.org/annotations.html#cocoa_mem>`_.
1626 <https://clang.llvm.org/docs/AttributeReference.html#availability>`_ together
1669 <https://clang.llvm.org/docs/AttributeReference.html#availability>`_ to it,
1710 clang supports an extension which allows the following in C:
1719 real and imaginary parts of a complex variable in standard C, given that clang
2015 support the format specifiers used by ``printf()``.
2114 C-style cast applied to each element of the first argument.
2755 Other coroutine builtins are either for internal clang use or for use during
2780 token `none`. If a user calls `__builin_suspend`, clang will insert `token none`
2914 Clang's non-standard C++11 attributes live in the ``clang`` attribute
3022 Currently the following builtins are implemented in clang:
3045 Analyzer <https://clang-analyzer.llvm.org/>`_. These attributes are documented
3047 <https://clang-analyzer.llvm.org/annotations.html>`_.
3072 To disable optimizations in a single function definition, the GNU-style or C++11
3078 // GNU-style attribute
3083 [[clang::optnone]] int bar() {
3088 range-based pragma is provided. Its syntax is ``#pragma clang optimize``
3098 #pragma clang optimize off
3108 #pragma clang optimize on
3113 Note that a stray ``#pragma clang optimize on`` does not selectively enable
3127 #pragma clang optimize off
3135 #pragma clang optimize on
3147 The ``#pragma clang loop`` directive is used to specify hints for optimizing the
3183 #pragma clang loop vectorize(enable)
3184 #pragma clang loop interleave(enable)
3206 #pragma clang loop vectorize_width(2)
3207 #pragma clang loop interleave_count(2)
3219 #pragma clang loop vectorize(enable)
3220 #pragma clang loop vectorize_predicate(enable)
3248 #pragma clang loop unroll(enable)
3260 #pragma clang loop unroll(full)
3272 #pragma clang loop unroll_count(8)
3293 #pragma clang loop distribute(enable)
3318 #pragma clang loop vectorize_width(4) interleave_count(8)
3332 The ``#pragma clang fp`` pragma allows floating-point options to be specified
3340 ``#pragma clang fp reassociate`` allows control over the reassociation
3353 #pragma clang fp reassociate(on)
3359 ``#pragma clang fp contract`` specifies whether the compiler should
3372 #pragma clang fp contract(fast)
3384 ``#pragma clang fp exceptions`` specifies floating point exception behavior. It
3392 #pragma clang fp exceptions(strict)
3398 A ``#pragma clang fp`` pragma may contain any number of options:
3403 #pragma clang fp exceptions(maytrap) contract(fast) reassociate(on)
3443 Specifying an attribute for multiple declarations (#pragma clang attribute)
3446 The ``#pragma clang attribute`` directive can be used to apply an attribute to
3447 multiple declarations. The ``#pragma clang attribute push`` variation of the
3448 directive pushes a new "scope" of ``#pragma clang attribute`` that attributes
3449 can be added to. The ``#pragma clang attribute (...)`` variation adds an
3450 attribute to that scope, and the ``#pragma clang attribute pop`` variation pops
3451 the scope. You can also use ``#pragma clang attribute push (...)``, which is a
3455 The attributes that are used in the ``#pragma clang attribute`` directives
3456 can be written using the GNU-style syntax:
3460 #pragma clang attribute push (__attribute__((annotate("custom"))), apply_to = function)
3464 #pragma clang attribute pop
3466 The attributes can also be written using the C++11 style syntax:
3470 #pragma clang attribute push ([[noreturn]], apply_to = function)
3474 #pragma clang attribute pop
3476 The ``__declspec`` style syntax is also supported:
3480 #pragma clang attribute push (__declspec(dllexport), apply_to = function)
3484 #pragma clang attribute pop
3490 expands to ``_Pragma("clang attribute")`` it's good hygiene (though not
3500 …#define ASSUME_NORETURN_BEGIN _Pragma("clang attribute AssumeNoreturn.push ([[noreturn]], apply_to…
3501 #define ASSUME_NORETURN_END _Pragma("clang attribute AssumeNoreturn.pop")
3503 …#define ASSUME_UNAVAILABLE_BEGIN _Pragma("clang attribute Unavailable.push (__attribute__((unavail…
3504 #define ASSUME_UNAVAILABLE_END _Pragma("clang attribute Unavailable.pop")
3518 your version of clang supports namespaces on ``#pragma clang attribute`` with
3537 #pragma clang attribute push([[nodiscard]], apply_to = enum)
3543 #pragma clang attribute pop
3545 #pragma clang attribute push([[nodiscard]], apply_to = any(record, enum))
3551 #pragma clang attribute pop
3554 #pragma clang attribute push([[nodiscard]], apply_to = any(record, namespace))
3556 #pragma clang attribute pop
3645 Not all attributes can be used with the ``#pragma clang attribute`` directive.
3655 Specifying section names for global objects (#pragma clang section)
3658 The ``#pragma clang section`` directive provides a means to assign section-names
3665 #pragma clang section bss="myBSS" data="myData" rodata="myRodata" relro="myRelro" text="myText"
3672 #pragma clang section bss="" data="" text="" rodata="" relro=""
3674 The ``#pragma clang section`` directive obeys the following rules:
3679 * The pragma clang section is enabled automatically, without need of any flags.
3689 * The ``#pragma clang section`` directive does not does try to infer section-kind
3695 ``#pragma clang section`` directive, is applied to that global.