Lines Matching +refs:clang +refs:format +refs:fallback +refs:style
50 #define __has_builtin(x) 0 // Compatibility with non-clang compilers.
81 #define __has_constexpr_builtin(x) 0 // Compatibility with non-clang compilers.
114 #define __has_feature(x) 0 // Compatibility with non-clang compilers.
157 name of a double-square-bracket-style attribute. The argument can either be a
174 #if __has_cpp_attribute(clang::fallthrough)
175 #define FALLTHROUGH [[clang::fallthrough]]
181 The attribute scope tokens ``clang`` and ``_Clang`` are interchangeable, as are
199 #define __has_c_attribute(x) 0 // Compatibility with non-clang compilers.
210 The attribute scope tokens ``clang`` and ``_Clang`` are interchangeable, as are
220 a GNU-style attribute. It evaluates to 1 if the attribute is supported by the
226 #define __has_attribute(x) 0 // Compatibility with non-clang compilers.
246 an attribute implemented as a Microsoft-style ``__declspec`` attribute. It
253 #define __has_declspec_attribute(x) 0 // Compatibility with non-clang compilers.
280 #ifdef __is_identifier // Compatibility with non-clang compilers.
318 // To avoid problem with non-clang compilers not having this macro.
343 // To avoid problem with non-clang compilers not having this macro.
452 Giving ``-maltivec`` option to clang enables support for AltiVec vector syntax
585 C-style cast yes yes yes no no
638 …undeven(T x) round x to the nearest integer value in floating point format, floating point …
774 ``__fp16`` is supported on every target, as it is purely a storage format; see below.
796 ``__bf16`` is purely a storage format; it is currently only supported on the following targets:
805 ``__fp16`` is a storage and interchange format only. This means that values of
809 Clang uses the ``binary16`` format from IEEE 754-2008 for ``__fp16``, not the ARM
810 alternative format.
817 format from IEEE 754-2008 for ``_Float16``.
841 certain library facilities with ``_Float16``; for example, there is no ``printf`` format
893 Clang allows C++-style ``[[]]`` attributes to be written on using-declarations.
898 [[clang::using_if_exists]] using foo::bar;
899 using foo::baz [[clang::using_if_exists]];
942 See `the C++ status page <https://clang.llvm.org/cxx_status.html#ts>`_ for
1365 More information could be found `here <https://clang.llvm.org/docs/Modules.html>`_.
1499 were made trivially relocatable via the ``clang::trivial_abi`` attribute.
1577 the clang implementation are in :doc:`Block-ABI-Apple<Block-ABI-Apple>`.
1619 This was changed to match GCC in clang-13; for better portability, symbolic
1727 Clang supports ARC-style weak and unsafe references in Objective-C even
1731 unconditionally. ARC-style weak and unsafe references cannot be used
1762 means the ARC-style qualifier in all non-GC modes and is no longer
1859 feature, clang provides default synthesis of those properties not declared
1862 of this feature in version of clang being used.
1875 `static analyzer <https://clang-analyzer.llvm.org>`_ Some exceptions may be
1912 <https://clang-analyzer.llvm.org/annotations.html#cocoa_mem>`_.
1933 <https://clang.llvm.org/docs/AttributeReference.html#availability>`_ together
1956 // Put fallback behavior for old macOS versions (and for non-mac
1976 <https://clang.llvm.org/docs/AttributeReference.html#availability>`_ to it,
2017 clang supports an extension which allows the following in C:
2026 real and imaginary parts of a complex variable in standard C, given that clang
2510 constexpr void constexpr_sprintf(std::string &out, const char *format,
2532 followed by a ``printf``-compatible format string and the corresponding
2537 In the format string, a suitable format specifier will be used for builtin
2538 types that Clang knows how to format. This includes standard builtin types, as
2541 that Clang doesn't know how to format, and the corresopnding argument will be a
2544 format specifier.
2649 C-style cast applied to each element of the first argument.
2936 ``[[clang::lifetimebound]]`` to the parameter of ``__builtin_addressof``.
3559 Other coroutine builtins are either for internal clang use or for use during
3583 token `none`. If a user calls `__builin_suspend`, clang will insert `token none`
3728 Clang's non-standard C++11 attributes live in the ``clang`` attribute
3836 Currently the following builtins are implemented in clang:
3859 Analyzer <https://clang-analyzer.llvm.org/>`_. These attributes are documented
3861 <https://clang-analyzer.llvm.org/annotations.html>`_.
3889 To disable optimizations in a single function definition, the GNU-style or C++11
3895 // GNU-style attribute
3900 [[clang::optnone]] int bar() {
3905 range-based pragma is provided. Its syntax is ``#pragma clang optimize``
3915 #pragma clang optimize off
3925 #pragma clang optimize on
3930 Note that a stray ``#pragma clang optimize on`` does not selectively enable
3944 #pragma clang optimize off
3952 #pragma clang optimize on
3965 the same as ``#pragma clang optimize``. All functions
4002 The ``#pragma clang loop`` directive is used to specify hints for optimizing the
4038 #pragma clang loop vectorize(enable)
4039 #pragma clang loop interleave(enable)
4061 #pragma clang loop vectorize_width(2)
4062 #pragma clang loop interleave_count(2)
4074 #pragma clang loop vectorize(enable)
4075 #pragma clang loop vectorize_predicate(enable)
4103 #pragma clang loop unroll(enable)
4115 #pragma clang loop unroll(full)
4127 #pragma clang loop unroll_count(8)
4151 #pragma clang loop distribute(enable)
4176 #pragma clang loop vectorize_width(4) interleave_count(8)
4190 The ``#pragma clang fp`` pragma allows floating-point options to be specified
4198 ``#pragma clang fp reassociate`` allows control over the reassociation
4211 #pragma clang fp reassociate(on)
4217 ``#pragma clang fp contract`` specifies whether the compiler should
4230 #pragma clang fp contract(fast)
4242 ``#pragma clang fp exceptions`` specifies floating point exception behavior. It
4250 #pragma clang fp exceptions(strict)
4256 A ``#pragma clang fp`` pragma may contain any number of options:
4261 #pragma clang fp exceptions(maytrap) contract(fast) reassociate(on)
4265 ``#pragma clang fp eval_method`` allows floating-point behavior to be specified
4270 When ``pragma clang fp eval_method(source)`` is enabled, the section of code
4275 When ``pragma clang fp eval_method(double)`` is enabled, the section of code
4280 When ``pragma clang fp eval_method(extended)`` is enabled, the section of code
4287 ``#pragma clang fp eval_method(source|double|extended)``.
4294 #pragma clang fp eval_method(extended)
4335 Specifying an attribute for multiple declarations (#pragma clang attribute)
4338 The ``#pragma clang attribute`` directive can be used to apply an attribute to
4339 multiple declarations. The ``#pragma clang attribute push`` variation of the
4340 directive pushes a new "scope" of ``#pragma clang attribute`` that attributes
4341 can be added to. The ``#pragma clang attribute (...)`` variation adds an
4342 attribute to that scope, and the ``#pragma clang attribute pop`` variation pops
4343 the scope. You can also use ``#pragma clang attribute push (...)``, which is a
4347 The attributes that are used in the ``#pragma clang attribute`` directives
4348 can be written using the GNU-style syntax:
4352 #pragma clang attribute push (__attribute__((annotate("custom"))), apply_to = function)
4356 #pragma clang attribute pop
4358 The attributes can also be written using the C++11 style syntax:
4362 #pragma clang attribute push ([[noreturn]], apply_to = function)
4366 #pragma clang attribute pop
4368 The ``__declspec`` style syntax is also supported:
4372 #pragma clang attribute push (__declspec(dllexport), apply_to = function)
4376 #pragma clang attribute pop
4379 only one syntax style can be used within a single directive:
4383 #pragma clang attribute push ([[noreturn, noinline]], apply_to = function)
4387 #pragma clang attribute pop
4389 #pragma clang attribute push (__attribute((noreturn, noinline)), apply_to = function)
4393 #pragma clang attribute pop
4396 expands to ``_Pragma("clang attribute")`` it's good hygiene (though not
4406 …#define ASSUME_NORETURN_BEGIN _Pragma("clang attribute AssumeNoreturn.push ([[noreturn]], apply_to…
4407 #define ASSUME_NORETURN_END _Pragma("clang attribute AssumeNoreturn.pop")
4409 …#define ASSUME_UNAVAILABLE_BEGIN _Pragma("clang attribute Unavailable.push (__attribute__((unavail…
4410 #define ASSUME_UNAVAILABLE_END _Pragma("clang attribute Unavailable.pop")
4424 your version of clang supports namespaces on ``#pragma clang attribute`` with
4443 #pragma clang attribute push([[nodiscard]], apply_to = enum)
4449 #pragma clang attribute pop
4451 #pragma clang attribute push([[nodiscard]], apply_to = any(record, enum))
4457 #pragma clang attribute pop
4460 #pragma clang attribute push([[nodiscard]], apply_to = any(record, namespace))
4462 #pragma clang attribute pop
4552 Not all attributes can be used with the ``#pragma clang attribute`` directive.
4562 Specifying section names for global objects (#pragma clang section)
4565 The ``#pragma clang section`` directive provides a means to assign section-names
4572 #pragma clang section bss="myBSS" data="myData" rodata="myRodata" relro="myRelro" text="myText"
4579 #pragma clang section bss="" data="" text="" rodata="" relro=""
4581 The ``#pragma clang section`` directive obeys the following rules:
4586 * The pragma clang section is enabled automatically, without need of any flags.
4596 * The ``#pragma clang section`` directive does not does try to infer section-kind
4602 ``#pragma clang section`` directive, is applied to that global.
4640 Clang supports the pragma ``#pragma clang deprecated``, which can be used to
4646 #pragma clang deprecated(MIN, "use std::min instead")
4652 ``#pragma clang deprecated`` should be preferred for this purpose over
4659 Clang supports the pragma ``#pragma clang restrict_expansion``, which can be
4669 #pragma clang restrict_expansion(TARGET_ARM, "<reason>")
4693 Clang supports the pragma ``#pragma clang final``, which can be used to
4699 #pragma clang final(FINAL_MACRO)