Lines Matching +full:interleave +full:- +full:mode
1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
8 //===----------------------------------------------------------------------===//
41 // This is for backward compatibility -- make enabling `_LIBCPP_ENABLE_ASSERTIONS` (which predates hardening modes)
42 // equivalent to setting the extensive mode. This is deprecated and will be removed in LLVM 20.
55 // - `_LIBCPP_HARDENING_MODE_NONE`;
56 // - `_LIBCPP_HARDENING_MODE_FAST`;
57 // - `_LIBCPP_HARDENING_MODE_EXTENSIVE`;
58 // - `_LIBCPP_HARDENING_MODE_DEBUG`.
62 // - `_LIBCPP_HARDENING_MODE_NONE` -- sets the hardening mode to "none" which disables all runtime hardening checks;
64 // - `_LIBCPP_HARDENING_MODE_FAST` -- sets that hardening mode to "fast". The fast mode enables security-critical checks
67 // - `_LIBCPP_HARDENING_MODE_EXTENSIVE` -- sets the hardening mode to "extensive". The extensive mode is a superset of
68 // the fast mode that additionally enables checks that are relatively cheap and prevent common types of logic errors
69 // but are not necessarily security-critical;
71 // - `_LIBCPP_HARDENING_MODE_DEBUG` -- sets the hardening mode to "debug". The debug mode is a superset of the extensive
72 // mode and enables all checks available in the library, including internal assertions. Checks that are part of the
73 // debug mode can be very expensive and thus the debug mode is intended to be used for testing, not in production.
75 // Inside the library, assertions are categorized so they can be cherry-picked based on the chosen hardening mode. These
76 // macros are only for internal use -- users should only pick one of the high-level hardening modes described above.
78 // - `_LIBCPP_ASSERT_VALID_INPUT_RANGE` -- checks that ranges (whether expressed as an iterator pair, an iterator and
80 // - the sentinel is reachable from the begin iterator;
81 // - TODO(hardening): both iterators refer to the same container.
83 // - `_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS` -- checks that any attempts to access a container element, whether through
85 // a non-existent element. For iterator checks to work, bounded iterators must be enabled in the ABI. Types like
86 // `optional` and `function` are considered one-element containers for the purposes of this check.
88 // - `_LIBCPP_ASSERT_NON_NULL` -- checks that the pointer being dereferenced is not null. On most modern platforms zero
93 // - `_LIBCPP_ASSERT_NON_OVERLAPPING_RANGES` -- for functions that take several ranges as arguments, checks that the
96 // - `_LIBCPP_ASSERT_VALID_DEALLOCATION` -- checks that an attempt to deallocate memory is valid (e.g. the given object
99 // - `_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL` -- checks that a call to an external API doesn't fail in
105 // - `_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR` -- checks any operations that exchange nodes between containers to make sure
108 // - `_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN` -- checks that the given argument is within the domain of valid arguments
112 // which doesn't cause any immediate issues in the library -- whatever the consequences are, they will happen in the
115 // - `_LIBCPP_ASSERT_PEDANTIC` -- checks prerequisites which are imposed by the Standard, but violating which happens to
118 // - `_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT` -- checks that the given argument satisfies the semantic requirements imposed
122 // - `_LIBCPP_ASSERT_INTERNAL` -- checks that internal invariants of the library hold. These assertions don't depend on
125 // - `_LIBCPP_ASSERT_UNCATEGORIZED` -- for assertions that haven't been properly classified yet.
127 // clang-format off
132 // clang-format on
160 // NOLINTNEXTLINE(libcpp-cpp-version-check)
201 # error "libc++ only supports C++03 with Clang-based compilers. Please enable C++11"
249 // Both MinGW and native MSVC provide a "MSVC"-like environment
263 // The size of wchar is 2 byte on 32-bit mode on AIX.
279 // is the recommended source of entropy for user-space programs.
281 // constructor *must* be "/dev/urandom" -- anything else is an error.
286 // constructor *must* be "/dev/urandom" -- anything else is an error.
290 // deliver high-quality entropy and cannot fail.
292 // constructor *must* be "/dev/urandom" -- anything else is an error.
299 // constructor *must* be "/dev/urandom" -- anything else is an error.
304 // constructor *must* be "/dev/urandom" -- anything else is an error.
353 // Objective-C++ features (opt-in)
522 // 2. The symbol is given an ABI tag that encodes the ODR-relevant properties of the library.
524 // versions or configurations of libc++ (such as exceptions vs no-exceptions). Indeed, if the
525 // program contains two definitions of a function, the ODR requires them to be token-by-token
532 // and the other aborts the program). This violates the ODR and makes the program ill-formed, and in
536 // A similar reasoning holds for many other properties that are ODR-affecting. Essentially any
538 // can be considered ODR-affecting. In practice, we don't encode all such properties in the ABI
540 // hardening mode.
543 // force-inlining all functions or giving internal linkage to all functions. Both these previous
555 // the implementation of a virtual function in an ABI-incompatible way in the first place,
566 // use compression mangling instead, see https://github.com/itanium-cxx-abi/cxx-abi/issues/70.
587 # if __has_warning("-Wc++23-extensions")
588 # define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED_CXX23_EXTENSION _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++23-extensions")
590 # define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED_CXX23_EXTENSION _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++2b-extensions")
599 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++11-extensions") \
600 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++14-extensions") \
601 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++17-extensions") \
602 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++20-extensions") \
604 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++14-extensions") \
605 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++17-extensions") \
606 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++20-extensions") \
607 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++23-extensions")
615 // clang-format off
631 // clang-format on
645 // clang-format off
652 // clang-format on
709 // Deprecations warnings are always enabled, except when users explicitly opt-out
730 "using -std=c++20 if you need to use these facilities.")
780 _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wdeprecated\"") \
781 _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
829 // clang-format off
846 // clang-format on
897 // clang-format off
901 // clang-format on
947 // of the types. In MinGW mode, __declspec evaluates to __attribute__, and thus
972 // when compiling for CUDA we use the non-underscored version of the noinline
978 // See https://github.com/llvm/llvm-project/pull/73838 for more details.
988 // disabling it without having to resort to #if-#endif, which has a larger
996 // clang-format off
999 // clang-format on
1011 // Configures the fopen close-on-exec mode character, if any. This string will
1012 // be appended to any mode string used by fstream for fopen/fdopen.
1014 // Not all platforms support this, but it helps avoid fd-leaks on platforms that
1023 // MSVC implements [[no_unique_address]] as a silent no-op currently.
1028 // Clang-cl does not yet (14.0) implement either [[no_unique_address]] or
1036 // Note that this can be replaced by #error as soon as clang-cl
1039 // We generally don't want to use this macro outside of C++20-only code,
1063 // '-Wctad-maybe-unsupported' compiler warning when CTAD is used in user code
1069 [[maybe_unused]] _ClassName(typename _Tag::__allow_ctad...)->_ClassName<_Tag...>
1073 ClassName(typename _Tag::__allow_ctad...)->ClassName<_Tag...>
1079 // TODO(varconst): currently, there are bugs in Clang's intrinsics when handling Objective-C++ `id`, so don't use
1080 // compiler intrinsics in the Objective-C++ mode.
1099 // NAME - the name of the functor
1100 // OP - type of the callable object with the reduction operation
1101 // omp_in - refers to the local partial result
1102 // omp_out - refers to the final value of the combiner operator
1103 // omp_priv - refers to the private copy of the initial value
1104 // omp_orig - refers to the original variable to be reduced
1110 # define _PSTL_PRAGMA_SIMD _Pragma("clang loop vectorize(enable) interleave(enable)")
1112 # define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _Pragma("clang loop vectorize(enable) interleave(enable)")
1113 # define _PSTL_PRAGMA_SIMD_SCAN(PRM) _Pragma("clang loop vectorize(enable) interleave(enable)")
1132 // Optional attributes - these are useful for a better QoI, but not required to be available
1219 // The attribute uses 1-based indices for ordinary and static member functions.
1220 // The attribute uses 2-based indices for non-static member functions.
1239 // Allow for build-time disabling of unsigned integer sanitization
1241 # define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
1246 // Clang-18 has support for deducing this, but it does not set the FTM.