diff options
Diffstat (limited to 'third_party/libcxx/include/c++/v1/__configuration')
8 files changed, 0 insertions, 1326 deletions
diff --git a/third_party/libcxx/include/c++/v1/__configuration/abi.h b/third_party/libcxx/include/c++/v1/__configuration/abi.h deleted file mode 100644 index 5ce040f..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/abi.h +++ /dev/null @@ -1,142 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_ABI_H -#define _LIBCPP___CONFIGURATION_ABI_H - -#include <__config_site> -#include <__configuration/compiler.h> -#include <__configuration/platform.h> - -#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -# pragma GCC system_header -#endif - -// FIXME: ABI detection should be done via compiler builtin macros. This -// is just a placeholder until Clang implements such macros. For now assume -// that Windows compilers pretending to be MSVC++ target the Microsoft ABI, -// and allow the user to explicitly specify the ABI to handle cases where this -// heuristic falls short. -#if _LIBCPP_ABI_FORCE_ITANIUM && _LIBCPP_ABI_FORCE_MICROSOFT -# error "Only one of _LIBCPP_ABI_FORCE_ITANIUM and _LIBCPP_ABI_FORCE_MICROSOFT can be true" -#elif _LIBCPP_ABI_FORCE_ITANIUM -# define _LIBCPP_ABI_ITANIUM -#elif _LIBCPP_ABI_FORCE_MICROSOFT -# define _LIBCPP_ABI_MICROSOFT -#else -// Windows uses the Microsoft ABI -# if defined(_WIN32) && defined(_MSC_VER) -# define _LIBCPP_ABI_MICROSOFT - -// 32-bit ARM uses the Itanium ABI with a few differences (array cookies, etc), -// and so does 64-bit ARM on Apple platforms. -# elif defined(__arm__) || (defined(__APPLE__) && defined(__aarch64__)) -# define _LIBCPP_ABI_ITANIUM_WITH_ARM_DIFFERENCES - -// Non-Apple 64-bit ARM uses the vanilla Itanium ABI -# elif defined(__aarch64__) -# define _LIBCPP_ABI_ITANIUM - -// We assume that other architectures also use the vanilla Itanium ABI too -# else -# define _LIBCPP_ABI_ITANIUM -# endif -#endif - -#if _LIBCPP_ABI_VERSION >= 2 -// TODO: Move the description of the remaining ABI flags to ABIGuarantees.rst or remove them. - -// Override the default return value of exception::what() for bad_function_call::what() -// with a string that is specific to bad_function_call (see http://wg21.link/LWG2233). -// This is an ABI break on platforms that sign and authenticate vtable function pointers -// because it changes the mangling of the virtual function located in the vtable, which -// changes how it gets signed. -# define _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE -// According to the Standard, `bitset::operator[] const` returns bool -# define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL - -// These flags are documented in ABIGuarantees.rst -# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT -# define _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE -# define _LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI -# define _LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI -# define _LIBCPP_ABI_FIX_CITYHASH_IMPLEMENTATION -# define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE -# define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE -# define _LIBCPP_ABI_IOS_ALLOW_ARBITRARY_FILL_VALUE -# define _LIBCPP_ABI_NO_COMPRESSED_PAIR_PADDING -# define _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE -# define _LIBCPP_ABI_NO_ITERATOR_BASES -# define _LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT -# define _LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER -# define _LIBCPP_ABI_OPTIMIZED_FUNCTION -# define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO -# define _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION -# define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY -# define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW -# define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION -# define _LIBCPP_ABI_TRIVIALLY_COPYABLE_BIT_ITERATOR - -#elif _LIBCPP_ABI_VERSION == 1 -// Feature macros for disabling pre ABI v1 features. All of these options -// are deprecated. -# if defined(__FreeBSD__) -# define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR -# endif -#endif - -// TODO(LLVM 22): Remove this check -#if defined(_LIBCPP_ABI_NO_ITERATOR_BASES) && !defined(_LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER) -# ifndef _LIBCPP_ONLY_NO_ITERATOR_BASES -# error "You probably want to define _LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER. This has been split out from" \ - " _LIBCPP_ABI_NO_ITERATOR_BASES to allow only removing the second iterator member, since they aren't really related." \ - "If you actually want this ABI configuration, please define _LIBCPP_ONLY_NO_ITERATOR_BASES instead." -# endif -#endif - -// We had some bugs where we use [[no_unique_address]] together with construct_at, -// which causes UB as the call on construct_at could write to overlapping subobjects -// -// https://llvm.org/PR70506 -// https://llvm.org/PR70494 -// -// To fix the bug we had to change the ABI of some classes to remove [[no_unique_address]] under certain conditions. -// The macro below is used for all classes whose ABI have changed as part of fixing these bugs. -#define _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS __attribute__((__abi_tag__("llvm18_nua"))) - -// [[msvc::no_unique_address]] seems to mostly affect empty classes, so the padding scheme for Itanium doesn't work. -#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_ABI_NO_COMPRESSED_PAIR_PADDING) -# define _LIBCPP_ABI_NO_COMPRESSED_PAIR_PADDING -#endif - -// Tracks the bounds of the array owned by std::unique_ptr<T[]>, allowing it to trap when accessed out-of-bounds. -// Note that limited bounds checking is also available outside of this ABI configuration, but only some categories -// of types can be checked. -// -// ABI impact: This causes the layout of std::unique_ptr<T[]> to change and its size to increase. -// This also affects the representation of a few library types that use std::unique_ptr -// internally, such as the unordered containers. -// #define _LIBCPP_ABI_BOUNDED_UNIQUE_PTR - -#if defined(_LIBCPP_COMPILER_CLANG_BASED) -# if defined(__APPLE__) -# if defined(__i386__) || defined(__x86_64__) -// use old string layout on x86_64 and i386 -# elif defined(__arm__) -// use old string layout on arm (which does not include aarch64/arm64), except on watch ABIs -# if defined(__ARM_ARCH_7K__) && __ARM_ARCH_7K__ >= 2 -# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT -# endif -# else -# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT -# endif -# endif -#endif - -#endif // _LIBCPP___CONFIGURATION_ABI_H diff --git a/third_party/libcxx/include/c++/v1/__configuration/attributes.h b/third_party/libcxx/include/c++/v1/__configuration/attributes.h deleted file mode 100644 index 39683b7..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/attributes.h +++ /dev/null @@ -1,466 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_ATTRIBUTES_H -#define _LIBCPP___CONFIGURATION_ATTRIBUTES_H - -#include <__config_site> -#include <__configuration/hardening.h> -#include <__configuration/language.h> - -#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -# pragma GCC system_header -#endif - -#ifndef __has_declspec_attribute -# define __has_declspec_attribute(__x) 0 -#endif - -// Attributes relevant for layout ABI -// ---------------------------------- - -#if __has_cpp_attribute(msvc::no_unique_address) -// MSVC implements [[no_unique_address]] as a silent no-op currently. -// (If/when MSVC breaks its C++ ABI, it will be changed to work as intended.) -// However, MSVC implements [[msvc::no_unique_address]] which does what -// [[no_unique_address]] is supposed to do, in general. -# define _LIBCPP_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] -#else -# define _LIBCPP_NO_UNIQUE_ADDRESS [[__no_unique_address__]] -#endif - -#define _LIBCPP_PACKED __attribute__((__packed__)) - -// Attributes affecting overload resolution -// ---------------------------------------- - -#if __has_attribute(__enable_if__) -# define _LIBCPP_PREFERRED_OVERLOAD __attribute__((__enable_if__(true, ""))) -#endif - -// Visibility attributes -// --------------------- - -#if defined(_LIBCPP_OBJECT_FORMAT_COFF) - -# ifdef _DLL -# define _LIBCPP_CRT_FUNC __declspec(dllimport) -# else -# define _LIBCPP_CRT_FUNC -# endif - -# if defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) || (defined(__MINGW32__) && !defined(_LIBCPP_BUILDING_LIBRARY)) -# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS -# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS -# define _LIBCPP_OVERRIDABLE_FUNC_VIS -# define _LIBCPP_EXPORTED_FROM_ABI -# elif defined(_LIBCPP_BUILDING_LIBRARY) -# if defined(__MINGW32__) -# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __declspec(dllexport) -# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS -# else -# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS -# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __declspec(dllexport) -# endif -# define _LIBCPP_OVERRIDABLE_FUNC_VIS __declspec(dllexport) -# define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllexport) -# else -# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __declspec(dllimport) -# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS -# define _LIBCPP_OVERRIDABLE_FUNC_VIS -# define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllimport) -# endif - -# define _LIBCPP_HIDDEN -# define _LIBCPP_TEMPLATE_DATA_VIS -# define _LIBCPP_NAMESPACE_VISIBILITY - -#else - -# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) -# define _LIBCPP_VISIBILITY(vis) __attribute__((__visibility__(vis))) -# else -# define _LIBCPP_VISIBILITY(vis) -# endif - -# define _LIBCPP_HIDDEN _LIBCPP_VISIBILITY("hidden") -# define _LIBCPP_TEMPLATE_DATA_VIS _LIBCPP_VISIBILITY("default") -# define _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_VISIBILITY("default") -# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_VISIBILITY("default") -# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS - -// TODO: Make this a proper customization point or remove the option to override it. -# ifndef _LIBCPP_OVERRIDABLE_FUNC_VIS -# define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_VISIBILITY("default") -# endif - -# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__) -# define _LIBCPP_NAMESPACE_VISIBILITY __attribute__((__type_visibility__("default"))) -# elif !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) -# define _LIBCPP_NAMESPACE_VISIBILITY __attribute__((__visibility__("default"))) -# else -# define _LIBCPP_NAMESPACE_VISIBILITY -# endif - -#endif // defined(_LIBCPP_OBJECT_FORMAT_COFF) - -// hide_from_abi -// ------------- - -#define _LIBCPP_ALWAYS_INLINE __attribute__((__always_inline__)) - -#if __has_attribute(exclude_from_explicit_instantiation) -# define _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION __attribute__((__exclude_from_explicit_instantiation__)) -#else -// Try to approximate the effect of exclude_from_explicit_instantiation -// (which is that entities are not assumed to be provided by explicit -// template instantiations in the dylib) by always inlining those entities. -# define _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION _LIBCPP_ALWAYS_INLINE -#endif - -#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_FAST -# define _LIBCPP_HARDENING_SIG f -#elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_EXTENSIVE -# define _LIBCPP_HARDENING_SIG s -#elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG -# define _LIBCPP_HARDENING_SIG d -#else -# define _LIBCPP_HARDENING_SIG n // "none" -#endif - -#if _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_OBSERVE -# define _LIBCPP_ASSERTION_SEMANTIC_SIG o -#elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE -# define _LIBCPP_ASSERTION_SEMANTIC_SIG q -#elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_ENFORCE -# define _LIBCPP_ASSERTION_SEMANTIC_SIG e -#else -# define _LIBCPP_ASSERTION_SEMANTIC_SIG i // `ignore` -#endif - -#if !_LIBCPP_HAS_EXCEPTIONS -# define _LIBCPP_EXCEPTIONS_SIG n -#else -# define _LIBCPP_EXCEPTIONS_SIG e -#endif - -#define _LIBCPP_ODR_SIGNATURE \ - _LIBCPP_CONCAT( \ - _LIBCPP_CONCAT(_LIBCPP_CONCAT(_LIBCPP_HARDENING_SIG, _LIBCPP_ASSERTION_SEMANTIC_SIG), _LIBCPP_EXCEPTIONS_SIG), \ - _LIBCPP_VERSION) - -// This macro marks a symbol as being hidden from libc++'s ABI. This is achieved -// on two levels: -// 1. The symbol is given hidden visibility, which ensures that users won't start exporting -// symbols from their dynamic library by means of using the libc++ headers. This ensures -// that those symbols stay private to the dynamic library in which it is defined. -// -// 2. The symbol is given an ABI tag that encodes the ODR-relevant properties of the library. -// This ensures that no ODR violation can arise from mixing two TUs compiled with different -// versions or configurations of libc++ (such as exceptions vs no-exceptions). Indeed, if the -// program contains two definitions of a function, the ODR requires them to be token-by-token -// equivalent, and the linker is allowed to pick either definition and discard the other one. -// -// For example, if a program contains a copy of `vector::at()` compiled with exceptions enabled -// *and* a copy of `vector::at()` compiled with exceptions disabled (by means of having two TUs -// compiled with different settings), the two definitions are both visible by the linker and they -// have the same name, but they have a meaningfully different implementation (one throws an exception -// and the other aborts the program). This violates the ODR and makes the program ill-formed, and in -// practice what will happen is that the linker will pick one of the definitions at random and will -// discard the other one. This can quite clearly lead to incorrect program behavior. -// -// A similar reasoning holds for many other properties that are ODR-affecting. Essentially any -// property that causes the code of a function to differ from the code in another configuration -// can be considered ODR-affecting. In practice, we don't encode all such properties in the ABI -// tag, but we encode the ones that we think are most important: library version, exceptions, and -// hardening mode. -// -// Note that historically, solving this problem has been achieved in various ways, including -// force-inlining all functions or giving internal linkage to all functions. Both these previous -// solutions suffer from drawbacks that lead notably to code bloat. -// -// Note that we use _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION to ensure that we don't depend -// on _LIBCPP_HIDE_FROM_ABI methods of classes explicitly instantiated in the dynamic library. -// -// Also note that the _LIBCPP_HIDE_FROM_ABI_VIRTUAL macro should be used on virtual functions -// instead of _LIBCPP_HIDE_FROM_ABI. That macro does not use an ABI tag. Indeed, the mangled -// name of a virtual function is part of its ABI, since some architectures like arm64e can sign -// the virtual function pointer in the vtable based on the mangled name of the function. Since -// we use an ABI tag that changes with each released version, the mangled name of the virtual -// function would change, which is incorrect. Note that it doesn't make much sense to change -// the implementation of a virtual function in an ABI-incompatible way in the first place, -// since that would be an ABI break anyway. Hence, the lack of ABI tag should not be noticeable. -// -// The macro can be applied to record and enum types. When the tagged type is nested in -// a record this "parent" record needs to have the macro too. Another use case for applying -// this macro to records and unions is to apply an ABI tag to inline constexpr variables. -// This can be useful for inline variables that are implementation details which are expected -// to change in the future. -// -// TODO: We provide a escape hatch with _LIBCPP_NO_ABI_TAG for folks who want to avoid increasing -// the length of symbols with an ABI tag. In practice, we should remove the escape hatch and -// use compression mangling instead, see https://github.com/itanium-cxx-abi/cxx-abi/issues/70. -#ifndef _LIBCPP_NO_ABI_TAG -# define _LIBCPP_HIDE_FROM_ABI \ - _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION \ - __attribute__((__abi_tag__(_LIBCPP_TOSTRING(_LIBCPP_ODR_SIGNATURE)))) -#else -# define _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION -#endif -#define _LIBCPP_HIDE_FROM_ABI_VIRTUAL _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION - -// Optional attributes -// ------------------- - -// these are useful for a better QoI, but not required to be available - -#define _LIBCPP_NOALIAS __attribute__((__malloc__)) -#define _LIBCPP_NODEBUG [[__gnu__::__nodebug__]] -#define _LIBCPP_NO_SANITIZE(...) __attribute__((__no_sanitize__(__VA_ARGS__))) -#define _LIBCPP_INIT_PRIORITY_MAX __attribute__((__init_priority__(100))) -#define _LIBCPP_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index) \ - __attribute__((__format__(archetype, format_string_index, first_format_arg_index))) - -#if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC) -# define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi"))) -#else -# define _LIBCPP_NO_CFI -#endif - -#if __has_attribute(__using_if_exists__) -# define _LIBCPP_USING_IF_EXISTS __attribute__((__using_if_exists__)) -#else -# define _LIBCPP_USING_IF_EXISTS -#endif - -#if __has_cpp_attribute(_Clang::__no_destroy__) -# define _LIBCPP_NO_DESTROY [[_Clang::__no_destroy__]] -#else -# define _LIBCPP_NO_DESTROY -#endif - -#if __has_attribute(__diagnose_if__) -# define _LIBCPP_DIAGNOSE_WARNING(...) __attribute__((__diagnose_if__(__VA_ARGS__, "warning"))) -#else -# define _LIBCPP_DIAGNOSE_WARNING(...) -#endif - -#if __has_attribute(__diagnose_if__) && !defined(_LIBCPP_APPLE_CLANG_VER) && \ - (!defined(_LIBCPP_CLANG_VER) || _LIBCPP_CLANG_VER >= 2001) -# define _LIBCPP_DIAGNOSE_IF(...) __attribute__((__diagnose_if__(__VA_ARGS__))) -#else -# define _LIBCPP_DIAGNOSE_IF(...) -#endif - -#define _LIBCPP_DIAGNOSE_NULLPTR_IF(condition, condition_description) \ - _LIBCPP_DIAGNOSE_IF( \ - condition, \ - "null passed to callee that requires a non-null argument" condition_description, \ - "warning", \ - "nonnull") - -#if __has_cpp_attribute(_Clang::__lifetimebound__) -# define _LIBCPP_LIFETIMEBOUND [[_Clang::__lifetimebound__]] -#else -# define _LIBCPP_LIFETIMEBOUND -#endif - -// This is to work around https://llvm.org/PR156809 -#ifndef _LIBCPP_CXX03_LANG -# define _LIBCPP_CTOR_LIFETIMEBOUND _LIBCPP_LIFETIMEBOUND -#else -# define _LIBCPP_CTOR_LIFETIMEBOUND -#endif - -#if __has_cpp_attribute(_Clang::__noescape__) -# define _LIBCPP_NOESCAPE [[_Clang::__noescape__]] -#else -# define _LIBCPP_NOESCAPE -#endif - -#if __has_cpp_attribute(_Clang::__no_specializations__) -# define _LIBCPP_NO_SPECIALIZATIONS \ - [[_Clang::__no_specializations__("Users are not allowed to specialize this standard library entity")]] -#else -# define _LIBCPP_NO_SPECIALIZATIONS -#endif - -#if __has_cpp_attribute(_Clang::__preferred_name__) -# define _LIBCPP_PREFERRED_NAME(x) [[_Clang::__preferred_name__(x)]] -#else -# define _LIBCPP_PREFERRED_NAME(x) -#endif - -#if __has_cpp_attribute(_Clang::__scoped_lockable__) -# define _LIBCPP_SCOPED_LOCKABLE [[_Clang::__scoped_lockable__]] -#else -# define _LIBCPP_SCOPED_LOCKABLE -#endif - -#if __has_cpp_attribute(_Clang::__capability__) -# define _LIBCPP_CAPABILITY(...) [[_Clang::__capability__(__VA_ARGS__)]] -#else -# define _LIBCPP_CAPABILITY(...) -#endif - -#if __has_attribute(__acquire_capability__) -# define _LIBCPP_ACQUIRE_CAPABILITY(...) __attribute__((__acquire_capability__(__VA_ARGS__))) -#else -# define _LIBCPP_ACQUIRE_CAPABILITY(...) -#endif - -#if __has_cpp_attribute(_Clang::__try_acquire_capability__) -# define _LIBCPP_TRY_ACQUIRE_CAPABILITY(...) [[_Clang::__try_acquire_capability__(__VA_ARGS__)]] -#else -# define _LIBCPP_TRY_ACQUIRE_CAPABILITY(...) -#endif - -#if __has_cpp_attribute(_Clang::__acquire_shared_capability__) -# define _LIBCPP_ACQUIRE_SHARED_CAPABILITY [[_Clang::__acquire_shared_capability__]] -#else -# define _LIBCPP_ACQUIRE_SHARED_CAPABILITY -#endif - -#if __has_cpp_attribute(_Clang::__try_acquire_shared_capability__) -# define _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(...) [[_Clang::__try_acquire_shared_capability__(__VA_ARGS__)]] -#else -# define _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(...) -#endif - -#if __has_cpp_attribute(_Clang::__release_capability__) -# define _LIBCPP_RELEASE_CAPABILITY [[_Clang::__release_capability__]] -#else -# define _LIBCPP_RELEASE_CAPABILITY -#endif - -#if __has_cpp_attribute(_Clang::__release_shared_capability__) -# define _LIBCPP_RELEASE_SHARED_CAPABILITY [[_Clang::__release_shared_capability__]] -#else -# define _LIBCPP_RELEASE_SHARED_CAPABILITY -#endif - -#if __has_attribute(__requires_capability__) -# define _LIBCPP_REQUIRES_CAPABILITY(...) __attribute__((__requires_capability__(__VA_ARGS__))) -#else -# define _LIBCPP_REQUIRES_CAPABILITY(...) -#endif - -#if __has_cpp_attribute(_Clang::__no_thread_safety_analysis__) -# define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS [[_Clang::__no_thread_safety_analysis__]] -#else -# define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS -#endif - -#if defined(_LIBCPP_ABI_MICROSOFT) && __has_declspec_attribute(empty_bases) -# define _LIBCPP_DECLSPEC_EMPTY_BASES __declspec(empty_bases) -#else -# define _LIBCPP_DECLSPEC_EMPTY_BASES -#endif - -// Allow for build-time disabling of unsigned integer sanitization -#if __has_attribute(no_sanitize) && !defined(_LIBCPP_COMPILER_GCC) -# define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow"))) -#else -# define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK -#endif - -#if __has_feature(nullability) -# define _LIBCPP_DIAGNOSE_NULLPTR _Nonnull -#else -# define _LIBCPP_DIAGNOSE_NULLPTR -#endif - -#if defined(__CUDACC__) || defined(__CUDA_ARCH__) || defined(__CUDA_LIBDEVICE__) -// The CUDA SDK contains an unfortunate definition for the __noinline__ macro, -// which breaks the regular __attribute__((__noinline__)) syntax. Therefore, -// when compiling for CUDA we use the non-underscored version of the noinline -// attribute. -// -// This is a temporary workaround and we still expect the CUDA SDK team to solve -// this issue properly in the SDK headers. -// -// See https://github.com/llvm/llvm-project/pull/73838 for more details. -# define _LIBCPP_NOINLINE __attribute__((noinline)) -#elif __has_attribute(__noinline__) -# define _LIBCPP_NOINLINE __attribute__((__noinline__)) -#else -# define _LIBCPP_NOINLINE -#endif - -// Deprecation macros -// ------------------ - -// Deprecations warnings are always enabled, except when users explicitly opt-out -// by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS. -#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) -# if __has_attribute(__deprecated__) -# define _LIBCPP_DEPRECATED __attribute__((__deprecated__)) -# define _LIBCPP_DEPRECATED_(m) __attribute__((__deprecated__(m))) -# elif _LIBCPP_STD_VER >= 14 -# define _LIBCPP_DEPRECATED [[deprecated]] -# define _LIBCPP_DEPRECATED_(m) [[deprecated(m)]] -# else -# define _LIBCPP_DEPRECATED -# define _LIBCPP_DEPRECATED_(m) -# endif -#else -# define _LIBCPP_DEPRECATED -# define _LIBCPP_DEPRECATED_(m) -#endif - -#if !defined(_LIBCPP_CXX03_LANG) -# define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED -#else -# define _LIBCPP_DEPRECATED_IN_CXX11 -#endif - -#if _LIBCPP_STD_VER >= 14 -# define _LIBCPP_DEPRECATED_IN_CXX14 _LIBCPP_DEPRECATED -#else -# define _LIBCPP_DEPRECATED_IN_CXX14 -#endif - -#if _LIBCPP_STD_VER >= 17 -# define _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_DEPRECATED -#else -# define _LIBCPP_DEPRECATED_IN_CXX17 -#endif - -#if _LIBCPP_STD_VER >= 20 -# define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED -#else -# define _LIBCPP_DEPRECATED_IN_CXX20 -#endif - -#if _LIBCPP_STD_VER >= 23 -# define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED -#else -# define _LIBCPP_DEPRECATED_IN_CXX23 -#endif - -#if _LIBCPP_STD_VER >= 26 -# define _LIBCPP_DEPRECATED_IN_CXX26 _LIBCPP_DEPRECATED -# define _LIBCPP_DEPRECATED_IN_CXX26_(m) _LIBCPP_DEPRECATED_(m) -#else -# define _LIBCPP_DEPRECATED_IN_CXX26 -# define _LIBCPP_DEPRECATED_IN_CXX26_(m) -#endif - -#if _LIBCPP_HAS_CHAR8_T -# define _LIBCPP_DEPRECATED_WITH_CHAR8_T _LIBCPP_DEPRECATED -#else -# define _LIBCPP_DEPRECATED_WITH_CHAR8_T -#endif - -#if __has_cpp_attribute(_Clang::__no_field_protection__) -# define _LIBCPP_DISABLE_POINTER_FIELD_PROTECTION [[_Clang::__no_field_protection__]] -#else -# define _LIBCPP_DISABLE_POINTER_FIELD_PROTECTION -#endif - -#endif // _LIBCPP___CONFIGURATION_ATTRIBUTES_H diff --git a/third_party/libcxx/include/c++/v1/__configuration/availability.h b/third_party/libcxx/include/c++/v1/__configuration/availability.h deleted file mode 100644 index f1a598b..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/availability.h +++ /dev/null @@ -1,299 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_AVAILABILITY_H -#define _LIBCPP___CONFIGURATION_AVAILABILITY_H - -#include <__configuration/compiler.h> -#include <__configuration/language.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -// This file defines a framework that can be used by vendors to encode the version of an operating system that various -// features of libc++ has been shipped in. This is primarily intended to allow safely deploying an executable built with -// a new version of the library on a platform containing an older version of the built library. -// Detailed documentation for this can be found at https://libcxx.llvm.org/VendorDocumentation.html#availability-markup - -// Availability markup is disabled when building the library, or when a non-Clang -// compiler is used because only Clang supports the necessary attributes. -// -// We also allow users to force-disable availability markup via the `_LIBCPP_DISABLE_AVAILABILITY` -// macro because that is the only way to work around a Clang bug related to availability -// attributes: https://llvm.org/PR134151. -// Once that bug has been fixed, we should remove the macro. -#if defined(_LIBCPP_BUILDING_LIBRARY) || defined(_LIBCXXABI_BUILDING_LIBRARY) || \ - !defined(_LIBCPP_COMPILER_CLANG_BASED) || defined(_LIBCPP_DISABLE_AVAILABILITY) -# undef _LIBCPP_HAS_VENDOR_AVAILABILITY_ANNOTATIONS -# define _LIBCPP_HAS_VENDOR_AVAILABILITY_ANNOTATIONS 0 -#endif - -// When availability annotations are disabled, we take for granted that features introduced -// in all versions of the library are available. -#if !_LIBCPP_HAS_VENDOR_AVAILABILITY_ANNOTATIONS - -# define _LIBCPP_INTRODUCED_IN_LLVM_22 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_22_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_21 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_21_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_20 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_20_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_19 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_18 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_18_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_16 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_16_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_15 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_14 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_14_ATTRIBUTE /* nothing */ - -# define _LIBCPP_INTRODUCED_IN_LLVM_12 1 -# define _LIBCPP_INTRODUCED_IN_LLVM_12_ATTRIBUTE /* nothing */ - -#elif defined(__APPLE__) - -// clang-format off - -// LLVM 22 -// TODO: Fill this in -# define _LIBCPP_INTRODUCED_IN_LLVM_22 0 -# define _LIBCPP_INTRODUCED_IN_LLVM_22_ATTRIBUTE __attribute__((unavailable)) - -// LLVM 21 -// TODO: Fill this in -# define _LIBCPP_INTRODUCED_IN_LLVM_21 0 -# define _LIBCPP_INTRODUCED_IN_LLVM_21_ATTRIBUTE __attribute__((unavailable)) - -// LLVM 20 -// -// Note that versions for most Apple OSes were bumped forward and aligned in that release. -# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 260000) || \ - (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 260000) || \ - (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 260000) || \ - (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 260000) || \ - (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 100000) -# define _LIBCPP_INTRODUCED_IN_LLVM_20 0 -# else -# define _LIBCPP_INTRODUCED_IN_LLVM_20 1 -# endif -# define _LIBCPP_INTRODUCED_IN_LLVM_20_ATTRIBUTE \ - __attribute__((availability(macos, strict, introduced = 26.0))) \ - __attribute__((availability(ios, strict, introduced = 26.0))) \ - __attribute__((availability(tvos, strict, introduced = 26.0))) \ - __attribute__((availability(watchos, strict, introduced = 26.0))) \ - __attribute__((availability(bridgeos, strict, introduced = 10.0))) - -// LLVM 19 -# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 150400) || \ - (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 180400) || \ - (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 180400) || \ - (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 110400) || \ - (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 90400) -# define _LIBCPP_INTRODUCED_IN_LLVM_19 0 -# else -# define _LIBCPP_INTRODUCED_IN_LLVM_19 1 -# endif -# define _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE \ - __attribute__((availability(macos, strict, introduced = 15.4))) \ - __attribute__((availability(ios, strict, introduced = 18.4))) \ - __attribute__((availability(tvos, strict, introduced = 18.4))) \ - __attribute__((availability(watchos, strict, introduced = 11.4))) \ - __attribute__((availability(bridgeos, strict, introduced = 9.4))) - -// LLVM 18 -# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 150000) || \ - (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 180000) || \ - (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 180000) || \ - (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 110000) || \ - (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 90000) || \ - (defined(__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__ < 240000) -# define _LIBCPP_INTRODUCED_IN_LLVM_18 0 -# else -# define _LIBCPP_INTRODUCED_IN_LLVM_18 1 -# endif -# define _LIBCPP_INTRODUCED_IN_LLVM_18_ATTRIBUTE \ - __attribute__((availability(macos, strict, introduced = 15.0))) \ - __attribute__((availability(ios, strict, introduced = 18.0))) \ - __attribute__((availability(tvos, strict, introduced = 18.0))) \ - __attribute__((availability(watchos, strict, introduced = 11.0))) \ - __attribute__((availability(bridgeos, strict, introduced = 9.0))) \ - __attribute__((availability(driverkit, strict, introduced = 24.0))) - -// LLVM 16 -# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 140000) || \ - (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 170000) || \ - (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 170000) || \ - (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 100000) || \ - (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 80000) || \ - (defined(__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__ < 230000) -# define _LIBCPP_INTRODUCED_IN_LLVM_16 0 -# else -# define _LIBCPP_INTRODUCED_IN_LLVM_16 1 -# endif -# define _LIBCPP_INTRODUCED_IN_LLVM_16_ATTRIBUTE \ - __attribute__((availability(macos, strict, introduced = 14.0))) \ - __attribute__((availability(ios, strict, introduced = 17.0))) \ - __attribute__((availability(tvos, strict, introduced = 17.0))) \ - __attribute__((availability(watchos, strict, introduced = 10.0))) \ - __attribute__((availability(bridgeos, strict, introduced = 8.0))) \ - __attribute__((availability(driverkit, strict, introduced = 23.0))) - -// LLVM 15 -# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 130300) || \ - (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 160300) || \ - (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 160300) || \ - (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 90300) || \ - (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 70500) || \ - (defined(__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__ < 220400) -# define _LIBCPP_INTRODUCED_IN_LLVM_15 0 -# else -# define _LIBCPP_INTRODUCED_IN_LLVM_15 1 -# endif -# define _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE \ - __attribute__((availability(macos, strict, introduced = 13.3))) \ - __attribute__((availability(ios, strict, introduced = 16.3))) \ - __attribute__((availability(tvos, strict, introduced = 16.3))) \ - __attribute__((availability(watchos, strict, introduced = 9.3))) \ - __attribute__((availability(bridgeos, strict, introduced = 7.5))) \ - __attribute__((availability(driverkit, strict, introduced = 22.4))) - -// LLVM 14 -# define _LIBCPP_INTRODUCED_IN_LLVM_14 _LIBCPP_INTRODUCED_IN_LLVM_15 -# define _LIBCPP_INTRODUCED_IN_LLVM_14_ATTRIBUTE _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE - -// LLVM 12 -# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 120300) || \ - (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 150300) || \ - (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 150300) || \ - (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 80300) || \ - (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 60000) || \ - (defined(__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__ < 210300) -# define _LIBCPP_INTRODUCED_IN_LLVM_12 0 -# else -# define _LIBCPP_INTRODUCED_IN_LLVM_12 1 -# endif -# define _LIBCPP_INTRODUCED_IN_LLVM_12_ATTRIBUTE \ - __attribute__((availability(macos, strict, introduced = 12.3))) \ - __attribute__((availability(ios, strict, introduced = 15.3))) \ - __attribute__((availability(tvos, strict, introduced = 15.3))) \ - __attribute__((availability(watchos, strict, introduced = 8.3))) \ - __attribute__((availability(bridgeos, strict, introduced = 6.0))) \ - __attribute__((availability(driverkit, strict, introduced = 21.3))) - -# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 110000) || \ - (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 150000) || \ - (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 150000) || \ - (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 80000) || \ - (defined(__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__ < 200000) -# warning "The selected platform is no longer supported by libc++." -# endif - -#else - -// ...New vendors can add availability markup here... - -# error \ - "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!" - -#endif - -// This controls the availability of new implementation of std::atomic's -// wait, notify_one and notify_all. The new implementation uses -// the native atomic wait/notify operations on platforms that support them -// based on the size of the atomic type, instead of the type itself. -#define _LIBCPP_AVAILABILITY_HAS_NEW_SYNC _LIBCPP_INTRODUCED_IN_LLVM_22 -#define _LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_INTRODUCED_IN_LLVM_22_ATTRIBUTE - -// This controls whether `std::__hash_memory` is available in the dylib, which -// is used for some `std::hash` specializations. -#define _LIBCPP_AVAILABILITY_HAS_HASH_MEMORY _LIBCPP_INTRODUCED_IN_LLVM_21 -// No attribute, since we've had hash in the headers before - -// This controls whether we provide a message for `bad_function_call::what()` that specific to `std::bad_function_call`. -// See https://wg21.link/LWG2233. This requires `std::bad_function_call::what()` to be available in the dylib. -#define _LIBCPP_AVAILABILITY_HAS_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE _LIBCPP_INTRODUCED_IN_LLVM_21 -// No attribute, since we've had bad_function_call::what() in the headers before - -// This controls the availability of floating-point std::from_chars functions. -// These overloads were added later than the integer overloads. -#define _LIBCPP_AVAILABILITY_HAS_FROM_CHARS_FLOATING_POINT _LIBCPP_INTRODUCED_IN_LLVM_20 -#define _LIBCPP_AVAILABILITY_FROM_CHARS_FLOATING_POINT _LIBCPP_INTRODUCED_IN_LLVM_20_ATTRIBUTE - -// This controls the availability of the C++20 time zone database. -// The parser code is built in the library. -#define _LIBCPP_AVAILABILITY_HAS_TZDB _LIBCPP_INTRODUCED_IN_LLVM_19 -#define _LIBCPP_AVAILABILITY_TZDB _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE - -// These macros determine whether we assume that std::bad_function_call and -// std::bad_expected_access provide a key function in the dylib. This allows -// centralizing their vtable and typeinfo instead of having all TUs provide -// a weak definition that then gets deduplicated. -#define _LIBCPP_AVAILABILITY_HAS_BAD_FUNCTION_CALL_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19 -#define _LIBCPP_AVAILABILITY_BAD_FUNCTION_CALL_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE -#define _LIBCPP_AVAILABILITY_HAS_BAD_EXPECTED_ACCESS_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19 -#define _LIBCPP_AVAILABILITY_BAD_EXPECTED_ACCESS_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE - -// These macros controls the availability of __cxa_init_primary_exception -// in the built library, which std::make_exception_ptr might use -// (see libcxx/include/__exception/exception_ptr.h). -#define _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION _LIBCPP_INTRODUCED_IN_LLVM_18 -#define _LIBCPP_AVAILABILITY_INIT_PRIMARY_EXCEPTION _LIBCPP_INTRODUCED_IN_LLVM_18_ATTRIBUTE - -// This controls the availability of the C++17 std::pmr library, -// which is implemented in large part in the built library. -// -// TODO: Enable std::pmr markup once https://llvm.org/PR40340 has been fixed -// Until then, it is possible for folks to try to use `std::pmr` when back-deploying to targets that don't support -// it and it'll be a load-time error, but we don't have a good alternative because the library won't compile if we -// use availability annotations until that bug has been fixed. -#define _LIBCPP_AVAILABILITY_HAS_PMR _LIBCPP_INTRODUCED_IN_LLVM_16 -#define _LIBCPP_AVAILABILITY_PMR - -// This controls whether the library claims to provide a default verbose -// termination function, and consequently whether the headers will try -// to use it when the mechanism isn't overriden at compile-time. -#define _LIBCPP_AVAILABILITY_HAS_VERBOSE_ABORT _LIBCPP_INTRODUCED_IN_LLVM_15 -#define _LIBCPP_AVAILABILITY_VERBOSE_ABORT _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE - -// This controls the availability of floating-point std::to_chars functions. -// These overloads were added later than the integer overloads. -#define _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT _LIBCPP_INTRODUCED_IN_LLVM_14 -#define _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_INTRODUCED_IN_LLVM_14_ATTRIBUTE - -// Enable additional explicit instantiations of iostreams components. This -// reduces the number of weak definitions generated in programs that use -// iostreams by providing a single strong definition in the shared library. -// -// TODO: Enable additional explicit instantiations on GCC once it supports exclude_from_explicit_instantiation, -// or once libc++ doesn't use the attribute anymore. -// TODO: Enable them on Windows once https://llvm.org/PR41018 has been fixed. -#if !defined(_LIBCPP_COMPILER_GCC) && !defined(_WIN32) -# define _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1 _LIBCPP_INTRODUCED_IN_LLVM_12 -#else -# define _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1 0 -#endif - -// Only define a bunch of symbols in the dylib if we need to be compatible with LLVM 7 headers or older -# if defined(_LIBCPP_BUILDING_LIBRARY) && _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 8 -# define _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 -# else -# define _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 _LIBCPP_HIDE_FROM_ABI -# endif - -#endif // _LIBCPP___CONFIGURATION_AVAILABILITY_H diff --git a/third_party/libcxx/include/c++/v1/__configuration/compiler.h b/third_party/libcxx/include/c++/v1/__configuration/compiler.h deleted file mode 100644 index 7cd81e0..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/compiler.h +++ /dev/null @@ -1,51 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_COMPILER_H -#define _LIBCPP___CONFIGURATION_COMPILER_H - -#include <__config_site> - -#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -# pragma GCC system_header -#endif - -#if defined(__apple_build_version__) -// Given AppleClang XX.Y.Z, _LIBCPP_APPLE_CLANG_VER is XXYZ (e.g. AppleClang 14.0.3 => 1403) -# define _LIBCPP_COMPILER_CLANG_BASED -# define _LIBCPP_APPLE_CLANG_VER (__apple_build_version__ / 10000) -#elif defined(__clang__) -# define _LIBCPP_COMPILER_CLANG_BASED -# define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__) -#elif defined(__GNUC__) -# define _LIBCPP_COMPILER_GCC -# define _LIBCPP_GCC_VER (__GNUC__ * 100 + __GNUC_MINOR__) -#endif - -#ifdef __cplusplus - -// Warn if a compiler version is used that is not supported anymore -// LLVM RELEASE Update the minimum compiler versions -# if defined(_LIBCPP_CLANG_VER) -# if _LIBCPP_CLANG_VER < 2001 -# warning "Libc++ only supports Clang 20 and later" -# endif -# elif defined(_LIBCPP_APPLE_CLANG_VER) -# if _LIBCPP_APPLE_CLANG_VER < 1700 -# warning "Libc++ only supports AppleClang 26 and later" -# endif -# elif defined(_LIBCPP_GCC_VER) -# if _LIBCPP_GCC_VER < 1500 -# warning "Libc++ only supports GCC 15 and later" -# endif -# endif - -#endif - -#endif // _LIBCPP___CONFIGURATION_COMPILER_H diff --git a/third_party/libcxx/include/c++/v1/__configuration/experimental.h b/third_party/libcxx/include/c++/v1/__configuration/experimental.h deleted file mode 100644 index bb38d82..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/experimental.h +++ /dev/null @@ -1,38 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_EXPERIMENTAL_H -#define _LIBCPP___CONFIGURATION_EXPERIMENTAL_H - -#include <__config_site> - -#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -# pragma GCC system_header -#endif - -#if __has_feature(experimental_library) -# ifndef _LIBCPP_ENABLE_EXPERIMENTAL -# define _LIBCPP_ENABLE_EXPERIMENTAL -# endif -#endif - -// Incomplete features get their own specific disabling flags. This makes it -// easier to grep for target specific flags once the feature is complete. -#if defined(_LIBCPP_ENABLE_EXPERIMENTAL) || defined(_LIBCPP_BUILDING_LIBRARY) -# define _LIBCPP_HAS_EXPERIMENTAL_LIBRARY 1 -#else -# define _LIBCPP_HAS_EXPERIMENTAL_LIBRARY 0 -#endif - -#define _LIBCPP_HAS_EXPERIMENTAL_PSTL _LIBCPP_HAS_EXPERIMENTAL_LIBRARY -#define _LIBCPP_HAS_EXPERIMENTAL_TZDB _LIBCPP_HAS_EXPERIMENTAL_LIBRARY -#define _LIBCPP_HAS_EXPERIMENTAL_SYNCSTREAM _LIBCPP_HAS_EXPERIMENTAL_LIBRARY -#define _LIBCPP_HAS_EXPERIMENTAL_HARDENING_OBSERVE_SEMANTIC _LIBCPP_HAS_EXPERIMENTAL_LIBRARY -#define _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR _LIBCPP_HAS_EXPERIMENTAL_LIBRARY - -#endif // _LIBCPP___CONFIGURATION_EXPERIMENTAL_H diff --git a/third_party/libcxx/include/c++/v1/__configuration/hardening.h b/third_party/libcxx/include/c++/v1/__configuration/hardening.h deleted file mode 100644 index 5723f5a..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/hardening.h +++ /dev/null @@ -1,215 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_HARDENING_H -#define _LIBCPP___CONFIGURATION_HARDENING_H - -#include <__config_site> -#include <__configuration/experimental.h> -#include <__configuration/language.h> - -#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -# pragma GCC system_header -#endif - -// TODO(LLVM 23): Remove this. We're making these an error to catch folks who might not have migrated. -// Since hardening went through several changes (many of which impacted user-facing macros), -// we're keeping these checks around for a bit longer than usual. Failure to properly configure -// hardening results in checks being dropped silently, which is a pretty big deal. -#if defined(_LIBCPP_ENABLE_ASSERTIONS) -# error "_LIBCPP_ENABLE_ASSERTIONS has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)" -#endif -#if defined(_LIBCPP_ENABLE_HARDENED_MODE) -# error "_LIBCPP_ENABLE_HARDENED_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)" -#endif -#if defined(_LIBCPP_ENABLE_SAFE_MODE) -# error "_LIBCPP_ENABLE_SAFE_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)" -#endif -#if defined(_LIBCPP_ENABLE_DEBUG_MODE) -# error "_LIBCPP_ENABLE_DEBUG_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)" -#endif - -// The library provides the macro `_LIBCPP_HARDENING_MODE` which can be set to one of the following values: -// -// - `_LIBCPP_HARDENING_MODE_NONE`; -// - `_LIBCPP_HARDENING_MODE_FAST`; -// - `_LIBCPP_HARDENING_MODE_EXTENSIVE`; -// - `_LIBCPP_HARDENING_MODE_DEBUG`. -// -// These values have the following effects: -// -// - `_LIBCPP_HARDENING_MODE_NONE` -- sets the hardening mode to "none" which disables all runtime hardening checks; -// -// - `_LIBCPP_HARDENING_MODE_FAST` -- sets that hardening mode to "fast". The fast mode enables security-critical checks -// that can be done with relatively little runtime overhead in constant time; -// -// - `_LIBCPP_HARDENING_MODE_EXTENSIVE` -- sets the hardening mode to "extensive". The extensive mode is a superset of -// the fast mode that additionally enables checks that are relatively cheap and prevent common types of logic errors -// but are not necessarily security-critical; -// -// - `_LIBCPP_HARDENING_MODE_DEBUG` -- sets the hardening mode to "debug". The debug mode is a superset of the extensive -// mode and enables all checks available in the library, including internal assertions. Checks that are part of the -// debug mode can be very expensive and thus the debug mode is intended to be used for testing, not in production. - -// Inside the library, assertions are categorized so they can be cherry-picked based on the chosen hardening mode. These -// macros are only for internal use -- users should only pick one of the high-level hardening modes described above. -// -// - `_LIBCPP_ASSERT_VALID_INPUT_RANGE` -- checks that ranges (whether expressed as an iterator pair, an iterator and -// a sentinel, an iterator and a count, or a `std::range`) given as input to library functions are valid: -// - the sentinel is reachable from the begin iterator; -// - TODO(hardening): both iterators refer to the same container. -// -// - `_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS` -- checks that any attempts to access a container element, whether through -// the container object or through an iterator, are valid and do not attempt to go out of bounds or otherwise access -// a non-existent element. For iterator checks to work, bounded iterators must be enabled in the ABI. Types like -// `optional` and `function` are considered one-element containers for the purposes of this check. -// -// - `_LIBCPP_ASSERT_NON_NULL` -- checks that the pointer being dereferenced is not null. On most modern platforms zero -// address does not refer to an actual location in memory, so a null pointer dereference would not compromize the -// memory security of a program (however, it is still undefined behavior that can result in strange errors due to -// compiler optimizations). -// -// - `_LIBCPP_ASSERT_NON_OVERLAPPING_RANGES` -- for functions that take several ranges as arguments, checks that the -// given ranges do not overlap. -// -// - `_LIBCPP_ASSERT_VALID_DEALLOCATION` -- checks that an attempt to deallocate memory is valid (e.g. the given object -// was allocated by the given allocator). Violating this category typically results in a memory leak. -// -// - `_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL` -- checks that a call to an external API doesn't fail in -// an unexpected manner. This includes triggering documented cases of undefined behavior in an external library (like -// attempting to unlock an unlocked mutex in pthreads). Any API external to the library falls under this category -// (from system calls to compiler intrinsics). We generally don't expect these failures to compromize memory safety or -// otherwise create an immediate security issue. -// -// - `_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR` -- checks any operations that exchange nodes between containers to make sure -// the containers have compatible allocators. -// -// - `_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN` -- checks that the given argument is within the domain of valid arguments -// for the function. Violating this typically produces an incorrect result (e.g. the clamp algorithm returns the -// original value without clamping it due to incorrect functors) or puts an object into an invalid state (e.g. -// a string view where only a subset of elements is possible to access). This category is for assertions violating -// which doesn't cause any immediate issues in the library -- whatever the consequences are, they will happen in the -// user code. -// -// - `_LIBCPP_ASSERT_PEDANTIC` -- checks prerequisites which are imposed by the Standard, but violating which happens to -// be benign in our implementation. -// -// - `_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT` -- checks that the given argument satisfies the semantic requirements imposed -// by the Standard. Typically, there is no simple way to completely prove that a semantic requirement is satisfied; -// thus, this would often be a heuristic check and it might be quite expensive. -// -// - `_LIBCPP_ASSERT_INTERNAL` -- checks that internal invariants of the library hold. These assertions don't depend on -// user input. -// -// - `_LIBCPP_ASSERT_UNCATEGORIZED` -- for assertions that haven't been properly classified yet. - -// clang-format off -# define _LIBCPP_HARDENING_MODE_NONE (1 << 1) -# define _LIBCPP_HARDENING_MODE_FAST (1 << 2) -# define _LIBCPP_HARDENING_MODE_EXTENSIVE (1 << 4) // Deliberately not ordered. -# define _LIBCPP_HARDENING_MODE_DEBUG (1 << 3) -// clang-format on - -#ifndef _LIBCPP_HARDENING_MODE - -# ifndef _LIBCPP_HARDENING_MODE_DEFAULT -# error _LIBCPP_HARDENING_MODE_DEFAULT is not defined. This definition should be set at configuration time in the \ -`__config_site` header, please make sure your installation of libc++ is not broken. -# endif - -# define _LIBCPP_HARDENING_MODE _LIBCPP_HARDENING_MODE_DEFAULT -#endif - -#if _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_NONE && _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_FAST && \ - _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_EXTENSIVE && \ - _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_DEBUG -# error _LIBCPP_HARDENING_MODE must be set to one of the following values: \ -_LIBCPP_HARDENING_MODE_NONE, \ -_LIBCPP_HARDENING_MODE_FAST, \ -_LIBCPP_HARDENING_MODE_EXTENSIVE, \ -_LIBCPP_HARDENING_MODE_DEBUG -#endif - -// The library provides the macro `_LIBCPP_ASSERTION_SEMANTIC` for configuring the assertion semantic used by hardening; -// it can be set to one of the following values: -// -// - `_LIBCPP_ASSERTION_SEMANTIC_IGNORE`; -// - `_LIBCPP_ASSERTION_SEMANTIC_OBSERVE`; -// - `_LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE`; -// - `_LIBCPP_ASSERTION_SEMANTIC_ENFORCE`. -// -// libc++ assertion semantics generally mirror the evaluation semantics of C++26 Contracts: -// - `ignore` evaluates the assertion but doesn't do anything if it fails (note that it differs from the Contracts -// `ignore` semantic which wouldn't evaluate the assertion at all); -// - `observe` logs an error (indicating, if possible, that the error is fatal) and continues execution; -// - `quick-enforce` terminates the program as fast as possible (via trapping); -// - `enforce` logs an error and then terminates the program. -// -// Additionally, a special `hardening-dependent` value selects the assertion semantic based on the hardening mode in -// effect: the production-capable modes (`fast` and `extensive`) map to `quick_enforce` and the `debug` mode maps to -// `enforce`. The `hardening-dependent` semantic cannot be selected explicitly, it is only used when no assertion -// semantic is provided by the user _and_ the library's default semantic is configured to be dependent on hardening. -// -// Notes: -// - Continuing execution after a hardening check fails results in undefined behavior; the `observe` semantic is meant -// to make adopting hardening easier but should not be used outside of this scenario; -// - C++26 wording for Library Hardening precludes a conforming Hardened implementation from using the Contracts -// `ignore` semantic when evaluating hardened preconditions in the Library. Libc++ allows using this semantic for -// hardened preconditions, however, be aware that using `ignore` does not produce a conforming "Hardened" -// implementation, unlike the other semantics above. -// clang-format off -# define _LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT (1 << 1) -# define _LIBCPP_ASSERTION_SEMANTIC_IGNORE (1 << 2) -# define _LIBCPP_ASSERTION_SEMANTIC_OBSERVE (1 << 3) -# define _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE (1 << 4) -# define _LIBCPP_ASSERTION_SEMANTIC_ENFORCE (1 << 5) -// clang-format on - -// If the user attempts to configure the assertion semantic, check that it is allowed in the current environment. -#if defined(_LIBCPP_ASSERTION_SEMANTIC) -# if !_LIBCPP_HAS_EXPERIMENTAL_LIBRARY -# error "Assertion semantics are an experimental feature." -# endif -# if defined(_LIBCPP_CXX03_LANG) -# error "Assertion semantics are not available in the C++03 mode." -# endif -#endif // defined(_LIBCPP_ASSERTION_SEMANTIC) - -// User-provided semantic takes top priority -- don't override if set. -#ifndef _LIBCPP_ASSERTION_SEMANTIC - -# ifndef _LIBCPP_ASSERTION_SEMANTIC_DEFAULT -# error _LIBCPP_ASSERTION_SEMANTIC_DEFAULT is not defined. This definition should be set at configuration time in \ -the `__config_site` header, please make sure your installation of libc++ is not broken. -# endif - -# if _LIBCPP_ASSERTION_SEMANTIC_DEFAULT != _LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT -# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_DEFAULT -# else -# if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG -# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_ENFORCE -# else -# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE -# endif -# endif // _LIBCPP_ASSERTION_SEMANTIC_DEFAULT != _LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT - -#endif // #ifndef _LIBCPP_ASSERTION_SEMANTIC - -// Finally, validate the selected semantic (in case the user tries setting it to an incorrect value): -#if _LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_IGNORE && \ - _LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_OBSERVE && \ - _LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE && \ - _LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_ENFORCE -# error _LIBCPP_ASSERTION_SEMANTIC must be set to one of the following values: \ -_LIBCPP_ASSERTION_SEMANTIC_IGNORE, \ -_LIBCPP_ASSERTION_SEMANTIC_OBSERVE, \ -_LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE, \ -_LIBCPP_ASSERTION_SEMANTIC_ENFORCE -#endif - -#endif // _LIBCPP___CONFIGURATION_HARDENING_H diff --git a/third_party/libcxx/include/c++/v1/__configuration/language.h b/third_party/libcxx/include/c++/v1/__configuration/language.h deleted file mode 100644 index 3137ba2..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/language.h +++ /dev/null @@ -1,59 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_LANGUAGE_H -#define _LIBCPP___CONFIGURATION_LANGUAGE_H - -#include <__config_site> - -#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -# pragma GCC system_header -#endif - -// NOLINTBEGIN(libcpp-cpp-version-check) -#ifdef __cplusplus -# if __cplusplus < 201103L -# define _LIBCPP_CXX03_LANG -# endif -# if __cplusplus <= 201103L -# define _LIBCPP_STD_VER 11 -# elif __cplusplus <= 201402L -# define _LIBCPP_STD_VER 14 -# elif __cplusplus <= 201703L -# define _LIBCPP_STD_VER 17 -# elif __cplusplus <= 202002L -# define _LIBCPP_STD_VER 20 -# elif __cplusplus <= 202302L -# define _LIBCPP_STD_VER 23 -# else -// Expected release year of the next C++ standard -# define _LIBCPP_STD_VER 26 -# endif -#endif // __cplusplus -// NOLINTEND(libcpp-cpp-version-check) - -#if defined(__cpp_rtti) && __cpp_rtti >= 199711L -# define _LIBCPP_HAS_RTTI 1 -#else -# define _LIBCPP_HAS_RTTI 0 -#endif - -#if defined(__cpp_exceptions) && __cpp_exceptions >= 199711L -# define _LIBCPP_HAS_EXCEPTIONS 1 -#else -# define _LIBCPP_HAS_EXCEPTIONS 0 -#endif - -#if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t) -# define _LIBCPP_HAS_CHAR8_T 0 -#else -# define _LIBCPP_HAS_CHAR8_T 1 -#endif - -#endif // _LIBCPP___CONFIGURATION_LANGUAGE_H diff --git a/third_party/libcxx/include/c++/v1/__configuration/platform.h b/third_party/libcxx/include/c++/v1/__configuration/platform.h deleted file mode 100644 index 644fe17..0000000 --- a/third_party/libcxx/include/c++/v1/__configuration/platform.h +++ /dev/null @@ -1,56 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___CONFIGURATION_PLATFORM_H -#define _LIBCPP___CONFIGURATION_PLATFORM_H - -#include <__config_site> - -#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -# pragma GCC system_header -#endif - -#if defined(__ELF__) -# define _LIBCPP_OBJECT_FORMAT_ELF 1 -#elif defined(__MACH__) -# define _LIBCPP_OBJECT_FORMAT_MACHO 1 -#elif defined(_WIN32) -# define _LIBCPP_OBJECT_FORMAT_COFF 1 -#elif defined(__wasm__) -# define _LIBCPP_OBJECT_FORMAT_WASM 1 -#elif defined(_AIX) -# define _LIBCPP_OBJECT_FORMAT_XCOFF 1 -#else -// ... add new file formats here ... -#endif - -// Need to detect which libc we're using if we're on Linux. -#if (defined(__linux__) || defined(__AMDGPU__) || defined(__NVPTX__)) && __has_include(<features.h>) -# include <features.h> -# if defined(__GLIBC_PREREQ) -# define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b) -# else -# define _LIBCPP_GLIBC_PREREQ(a, b) 0 -# endif // defined(__GLIBC_PREREQ) -#else -# define _LIBCPP_GLIBC_PREREQ(a, b) 0 -#endif - -#ifndef __BYTE_ORDER__ -# error \ - "Your compiler doesn't seem to define __BYTE_ORDER__, which is required by libc++ to know the endianness of your target platform" -#endif - -#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -# define _LIBCPP_LITTLE_ENDIAN -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -# define _LIBCPP_BIG_ENDIAN -#endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ - -#endif // _LIBCPP___CONFIGURATION_PLATFORM_H |