Lines Matching +refs:clang +refs:format +refs:buffer
50 #define __has_builtin(x) 0 // Compatibility with non-clang compilers.
85 #define __has_feature(x) 0 // Compatibility with non-clang compilers.
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
197 #define __has_attribute(x) 0 // Compatibility with non-clang compilers.
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
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
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()``.
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`
2873 void example(char* buffer) {
2874 if (__builtin_is_aligned(buffer, 64)) {
2875 do_fast_aligned_copy(buffer);
2877 do_unaligned_copy(buffer);
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>`_.
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
3460 #pragma clang attribute push (__attribute__((annotate("custom"))), apply_to = function)
3464 #pragma clang attribute pop
3470 #pragma clang attribute push ([[noreturn]], apply_to = function)
3474 #pragma clang attribute pop
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.
3719 char* buffer = malloc(size);
3720 strlcpy(buffer, "some string", strlen("some string"));
3722 …// __builtin___strlcpy_chk(buffer, "some string", strlen("some string"), __builtin_object_size(buf…
3725 Since the size of ``buffer`` can't be known at compile time, Clang will fold
3726 ``__builtin_object_size(buffer, 0)`` into ``-1``. However, if this was written
3727 as ``__builtin_dynamic_object_size(buffer, 0)``, Clang will fold it into