Commit 54b67c20259f697f1e0c4532a5ee7e5d3f01eb1e | zig

lib/libcxx/include/__bit_reference+15

...	@@ -1122,6 +1122,21 @@ public:	...	@@ -1122,6 +1122,21 @@ public:
1122	__bit_iterator(const __type_for_copy_to_const& __it) _NOEXCEPT	1122	__bit_iterator(const __type_for_copy_to_const& __it) _NOEXCEPT
1123	: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}	1123	: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
1124		1124
		1125	// The non-const __bit_iterator has historically had a non-trivial
		1126	// copy constructor (as a quirk of its construction). We need to maintain
		1127	// this for ABI purposes.
		1128	using __type_for_abi_non_trivial_copy_ctor =
		1129	_If<!_IsConst, __bit_iterator, struct __private_nat>;
		1130
		1131	_LIBCPP_INLINE_VISIBILITY
		1132	__bit_iterator(__type_for_abi_non_trivial_copy_ctor const& __it) _NOEXCEPT
		1133	: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
		1134
		1135	// Always declare the copy assignment operator since the implicit declaration
		1136	// is deprecated.
		1137	_LIBCPP_INLINE_VISIBILITY
		1138	__bit_iterator& operator=(__bit_iterator const&) = default;
		1139
1125	_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT	1140	_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
1126	{return reference(__seg_, __storage_type(1) << __ctz_);}	1141	{return reference(__seg_, __storage_type(1) << __ctz_);}
1127		1142

lib/libcxx/include/__config+71-42

 @@ -32,7 +32,7 @@
 #  define _GNUC_VER_NEW 0
 #endif
-#define _LIBCPP_VERSION 10000
+#define _LIBCPP_VERSION 11000
 #ifndef _LIBCPP_ABI_VERSION
 #  define _LIBCPP_ABI_VERSION 1
 @@ -102,6 +102,9 @@
 #  define _LIBCPP_ABI_OPTIMIZED_FUNCTION
 // All the regex constants must be distinct and nonzero.
 #  define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
+// Re-worked external template instantiations for std::string with a focus on
+// performance and fast-path inlining.
+#  define _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
 #elif _LIBCPP_ABI_VERSION == 1
 #  if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
 // Enable compiling copies of now inline methods into the dylib to support
 @@ -395,12 +398,12 @@
 #if defined(_LIBCPP_COMPILER_CLANG)
-// _LIBCPP_ALTERNATE_STRING_LAYOUT is an old name for
+#if defined(_LIBCPP_ALTERNATE_STRING_LAYOUT)
-// _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT left here for backward compatibility.
+#  error _LIBCPP_ALTERNATE_STRING_LAYOUT is deprecated, please use _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT instead
-#if (defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) &&       \
+#endif
-     (!defined(__arm__) || __ARM_ARCH_7K__ >= 2)) ||                           \
+#if defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) &&       \
-    defined(_LIBCPP_ALTERNATE_STRING_LAYOUT)
+    (!defined(__arm__) || __ARM_ARCH_7K__ >= 2)
-#define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+#  define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 #endif
 #if __has_feature(cxx_alignas)
 @@ -416,12 +419,8 @@ typedef __char16_t char16_t;
 typedef __char32_t char32_t;
 #endif
-#if !(__has_feature(cxx_exceptions)) && !defined(_LIBCPP_NO_EXCEPTIONS)
+#if !__has_feature(cxx_exceptions)
-#define _LIBCPP_NO_EXCEPTIONS
+#  define _LIBCPP_NO_EXCEPTIONS
-#endif
-#if !(__has_feature(cxx_rtti)) && !defined(_LIBCPP_NO_RTTI)
-#define _LIBCPP_NO_RTTI
 #endif
 #if !(__has_feature(cxx_strong_enums))
 @@ -467,6 +466,14 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_OBJC_ARC_WEAK
 #endif
+#if __has_extension(blocks)
+#  define _LIBCPP_HAS_EXTENSION_BLOCKS
+#endif
+#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS) && defined(__APPLE__)
+#  define _LIBCPP_HAS_BLOCKS_RUNTIME
+#endif
 #if !(__has_feature(cxx_relaxed_constexpr))
 #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR
 #endif
 @@ -492,6 +499,10 @@ typedef __char32_t char32_t;
 #define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER
 #endif
+#if __has_builtin(__builtin_constant_p)
+#define _LIBCPP_COMPILER_HAS_BUILTIN_CONSTANT_P
+#endif
 #if !__is_identifier(__has_unique_object_representations)
 #define _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS
 #endif
 @@ -513,8 +524,8 @@ typedef __char32_t char32_t;
 #define _LIBCPP_NORETURN __attribute__((noreturn))
-#if !__EXCEPTIONS && !defined(_LIBCPP_NO_EXCEPTIONS)
+#if !__EXCEPTIONS
-#define _LIBCPP_NO_EXCEPTIONS
+#  define _LIBCPP_NO_EXCEPTIONS
 #endif
 // Determine if GCC supports relaxed constexpr
 @@ -533,9 +544,7 @@ typedef __char32_t char32_t;
 #if _GNUC_VER >= 700
 #define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER
-#endif
+#define _LIBCPP_COMPILER_HAS_BUILTIN_CONSTANT_P
-#if _GNUC_VER >= 700
 #define _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS
 #endif
 @@ -745,14 +754,14 @@ typedef __char32_t char32_t;
 #  endif
 #endif
-#ifndef _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT
+#ifndef _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
-# ifdef _LIBCPP_OBJECT_FORMAT_COFF // Windows binaries can't merge typeinfos.
+#  ifdef _LIBCPP_OBJECT_FORMAT_COFF // Windows binaries can't merge typeinfos.
-# define _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT 0
+#    define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 2
-#else
+#  else
-// TODO: This isn't strictly correct on ELF platforms due to llvm.org/PR37398
+     // TODO: This isn't strictly correct on ELF platforms due to llvm.org/PR37398
-// And we should consider defaulting to OFF.
+     // And we should consider defaulting to OFF.
-# define _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT 1
+#    define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 1
-#endif
+#  endif
 #endif
 #ifndef _LIBCPP_HIDE_FROM_ABI
 @@ -901,6 +910,10 @@ typedef unsigned int   char32_t;
 #define _LIBCPP_EXTERN_TEMPLATE2(...) extern template __VA_ARGS__;
 #endif
+#ifndef _LIBCPP_EXTERN_TEMPLATE_DEFINE
+#define _LIBCPP_EXTERN_TEMPLATE_DEFINE(...) template __VA_ARGS__;
+#endif
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCPP_MSVCRT_LIKE) || \
     defined(__sun__) || defined(__NetBSD__) || defined(__CloudABI__)
 #define _LIBCPP_LOCALE__L_EXTENSIONS 1
 @@ -1092,17 +1105,12 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #endif
 // Try to find out if RTTI is disabled.
-// g++ and cl.exe have RTTI on by default and define a macro when it is.
+#if defined(_LIBCPP_COMPILER_CLANG) && !__has_feature(cxx_rtti)
-// g++ only defines the macro in 4.3.2 and onwards.
+#  define _LIBCPP_NO_RTTI
-#if !defined(_LIBCPP_NO_RTTI)
+#elif defined(__GNUC__) && !defined(__GXX_RTTI)
-#  if defined(__GNUC__) && \
+#  define _LIBCPP_NO_RTTI
-      ((__GNUC__ >= 5) || \
+#elif defined(_LIBCPP_COMPILER_MSVC) && !defined(_CPPRTTI)
-       (__GNUC__ == 4 && (__GNUC_MINOR__ >= 3 || __GNUC_PATCHLEVEL__ >= 2))) && \
+#  define _LIBCPP_NO_RTTI
-      !defined(__GXX_RTTI)
-#    define _LIBCPP_NO_RTTI
-#  elif defined(_LIBCPP_COMPILER_MSVC) && !defined(_CPPRTTI)
-#    define _LIBCPP_NO_RTTI
-#  endif
 #endif
 #ifndef _LIBCPP_WEAK
 @@ -1125,7 +1133,8 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
       (defined(__MINGW32__) && __has_include(<pthread.h>))
 #    define _LIBCPP_HAS_THREAD_API_PTHREAD
 #  elif defined(__Fuchsia__)
-#    define _LIBCPP_HAS_THREAD_API_C11
+     // TODO(44575): Switch to C11 thread API when possible.
+#    define _LIBCPP_HAS_THREAD_API_PTHREAD
 #  elif defined(_LIBCPP_WIN32API)
 #    define _LIBCPP_HAS_THREAD_API_WIN32
 #  else
 @@ -1360,6 +1369,7 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 // Decide whether to use availability macros.
 #if !defined(_LIBCPP_BUILDING_LIBRARY) &&                                      \
+    !defined(_LIBCXXABI_BUILDING_LIBRARY) &&                                   \
     !defined(_LIBCPP_DISABLE_AVAILABILITY) &&                                  \
     __has_feature(attribute_availability_with_strict) &&                       \
     __has_feature(attribute_availability_in_templates) &&                      \
 @@ -1377,10 +1387,10 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
      __attribute__((availability(tvos,strict,introduced=10.0)))                \
      __attribute__((availability(watchos,strict,introduced=3.0)))
 #  define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS                             \
-     __attribute__((availability(macosx,strict,introduced=10.14)))             \
+     __attribute__((availability(macosx,strict,introduced=10.13)))             \
-     __attribute__((availability(ios,strict,introduced=12.0)))                 \
+     __attribute__((availability(ios,strict,introduced=11.0)))                 \
-     __attribute__((availability(tvos,strict,introduced=12.0)))                \
+     __attribute__((availability(tvos,strict,introduced=11.0)))                \
-     __attribute__((availability(watchos,strict,introduced=5.0)))
+     __attribute__((availability(watchos,strict,introduced=4.0)))
 #  define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS                              \
      _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
 #  define _LIBCPP_AVAILABILITY_BAD_ANY_CAST                                    \
 @@ -1421,6 +1431,10 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
      _Pragma("clang attribute pop")                                            \
      _Pragma("clang attribute pop")                                            \
      _Pragma("clang attribute pop")
+#  define _LIBCPP_AVAILABILITY_TO_CHARS                                        \
+     _LIBCPP_AVAILABILITY_FILESYSTEM
+#  define _LIBCPP_AVAILABILITY_SYNC                                            \
+     __attribute__((unavailable))
 #else
 #  define _LIBCPP_AVAILABILITY_SHARED_MUTEX
 #  define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS
 @@ -1435,6 +1449,8 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #  define _LIBCPP_AVAILABILITY_FILESYSTEM
 #  define _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 #  define _LIBCPP_AVAILABILITY_FILESYSTEM_POP
+#  define _LIBCPP_AVAILABILITY_TO_CHARS
+#  define _LIBCPP_AVAILABILITY_SYNC
 #endif
 // Define availability that depends on _LIBCPP_NO_EXCEPTIONS.
 @@ -1518,6 +1534,19 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #  define _LIBCPP_FOPEN_CLOEXEC_MODE
 #endif
+#ifdef _LIBCPP_COMPILER_HAS_BUILTIN_CONSTANT_P
+#define _LIBCPP_BUILTIN_CONSTANT_P(x) __builtin_constant_p(x)
+#else
+#define _LIBCPP_BUILTIN_CONSTANT_P(x) false
+#endif
+// Support for _FILE_OFFSET_BITS=64 landed gradually in Android, so the full set
+// of functions used in cstdio may not be available for low API levels when
+// using 64-bit file offsets on LP32.
+#if defined(__BIONIC__) && defined(__USE_FILE_OFFSET64) && __ANDROID_API__ < 24
+#define _LIBCPP_HAS_NO_FGETPOS_FSETPOS
+#endif
 #endif // __cplusplus
 #endif // _LIBCPP_CONFIG

lib/libcxx/include/__config_site.in+3-1

 @@ -27,7 +27,9 @@
 #cmakedefine _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL
 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_NO_VCRUNTIME
-#cmakedefine01 _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT
+#ifndef _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
+#cmakedefine _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION @_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION@
+#endif
 #cmakedefine _LIBCPP_ABI_NAMESPACE @_LIBCPP_ABI_NAMESPACE@
 #cmakedefine _LIBCPP_HAS_PARALLEL_ALGORITHMS

lib/libcxx/include/__functional_base+2-2

...	@@ -522,7 +522,7 @@ inline _LIBCPP_INLINE_VISIBILITY	...	@@ -522,7 +522,7 @@ inline _LIBCPP_INLINE_VISIBILITY
522	reference_wrapper<_Tp>	522	reference_wrapper<_Tp>
523	ref(reference_wrapper<_Tp> __t) _NOEXCEPT	523	ref(reference_wrapper<_Tp> __t) _NOEXCEPT
524	{	524	{
525	return ref(__t.get());	525	return _VSTD::ref(__t.get());
526	}	526	}
527		527
528	template <class _Tp>	528	template <class _Tp>
...	@@ -538,7 +538,7 @@ inline _LIBCPP_INLINE_VISIBILITY	...	@@ -538,7 +538,7 @@ inline _LIBCPP_INLINE_VISIBILITY
538	reference_wrapper<const _Tp>	538	reference_wrapper<const _Tp>
539	cref(reference_wrapper<_Tp> __t) _NOEXCEPT	539	cref(reference_wrapper<_Tp> __t) _NOEXCEPT
540	{	540	{
541	return cref(__t.get());	541	return _VSTD::cref(__t.get());
542	}	542	}
543		543
544	#ifndef _LIBCPP_CXX03_LANG	544	#ifndef _LIBCPP_CXX03_LANG

lib/libcxx/include/__libcpp_version+1-1

...	@@ -1 +1 @@	...	@@ -1 +1 @@
1	10000	1	11000

lib/libcxx/include/__locale+6

 @@ -496,7 +496,13 @@ public:
     static const mask punct  = 1<<7;
     static const mask xdigit = 1<<8;
     static const mask blank  = 1<<9;
+#if defined(__BIONIC__)
+    // Historically this was a part of regex_traits rather than ctype_base. The
+    // historical value of the constant is preserved for ABI compatibility.
+    static const mask __regex_word = 0x8000;
+#else
     static const mask __regex_word = 1<<10;
+#endif // defined(__BIONIC__)
 #endif
     static const mask alnum  = alpha | digit;
     static const mask graph  = alnum | punct;

lib/libcxx/include/__string+117

...	@@ -70,6 +70,123 @@ _LIBCPP_PUSH_MACROS	...	@@ -70,6 +70,123 @@ _LIBCPP_PUSH_MACROS
70		70
71	_LIBCPP_BEGIN_NAMESPACE_STD	71	_LIBCPP_BEGIN_NAMESPACE_STD
72		72
		73	// The the extern template ABI lists are kept outside of <string> to improve the
		74	// readability of that header.
		75
		76	// The extern template ABI lists are kept outside of <string> to improve the
		77	// readability of that header. We maintain 2 ABI lists:
		78	// - _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST
		79	// - _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST
		80	// As the name implies, the ABI lists define the V1 (Stable) and unstable ABI.
		81	//
		82	// For unstable, we may explicitly remove function that are external in V1,
		83	// and add (new) external functions to better control inlining and compiler
		84	// optimization opportunities.
		85	//
		86	// For stable, the ABI list should rarely change, except for adding new
		87	// functions supporting new c++ version / API changes. Typically entries
		88	// must never be removed from the stable list.
		89	#define _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
		90	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
		91	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
		92	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
		93	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&)) \
		94	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
		95	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, std::allocator<_CharType> const&)) \
		96	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
		97	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::~basic_string()) \
		98	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
		99	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
		100	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
		101	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type)) \
		102	_Func(_LIBCPP_FUNC_VIS const _CharType& basic_string<_CharType>::at(size_type) const) \
		103	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
		104	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
		105	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
		106	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*, size_type)) \
		107	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::reserve(size_type)) \
		108	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
		109	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
		110	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
		111	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, std::allocator<_CharType> const&)) \
		112	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
		113	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(size_type, value_type)) \
		114	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
		115	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
		116	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
		117	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
		118	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::push_back(value_type)) \
		119	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
		120	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
		121	_Func(_LIBCPP_FUNC_VIS const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
		122	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
		123	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::erase(size_type, size_type)) \
		124	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
		125	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(value_type const*) const) \
		126	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
		127	_Func(_LIBCPP_FUNC_VIS _CharType& basic_string<_CharType>::at(size_type)) \
		128	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*)) \
		129	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
		130	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
		131	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
		132	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(basic_string const&)) \
		133	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
		134	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
		135	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
		136	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
		137	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
		138
		139	#define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
		140	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
		141	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
		142	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
		143	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
		144	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
		145	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::~basic_string()) \
		146	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
		147	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
		148	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
		149	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type)) \
		150	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init_copy_ctor_external(value_type const*, size_type)) \
		151	_Func(_LIBCPP_FUNC_VIS const _CharType& basic_string<_CharType>::at(size_type) const) \
		152	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
		153	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
		154	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
		155	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*, size_type)) \
		156	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*)) \
		157	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::reserve(size_type)) \
		158	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
		159	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
		160	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
		161	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, std::allocator<_CharType> const&)) \
		162	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
		163	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(size_type, value_type)) \
		164	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
		165	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
		166	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
		167	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
		168	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<false>(value_type const*, size_type)) \
		169	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<true>(value_type const*, size_type)) \
		170	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::push_back(value_type)) \
		171	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
		172	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
		173	_Func(_LIBCPP_FUNC_VIS const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
		174	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
		175	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__erase_external_with_move(size_type, size_type)) \
		176	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
		177	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(value_type const*) const) \
		178	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
		179	_Func(_LIBCPP_FUNC_VIS _CharType& basic_string<_CharType>::at(size_type)) \
		180	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
		181	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
		182	_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
		183	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
		184	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
		185	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
		186	_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
		187	_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
		188
		189
73	// char_traits	190	// char_traits
74		191
75	template <class _CharT>	192	template <class _CharT>

lib/libcxx/include/__threading_support+111

...	@@ -26,6 +26,12 @@	...	@@ -26,6 +26,12 @@
26	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)	26	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
27	# include <pthread.h>	27	# include <pthread.h>
28	# include <sched.h>	28	# include <sched.h>
		29	# ifdef __APPLE__
		30	# define _LIBCPP_NO_NATIVE_SEMAPHORES
		31	# endif
		32	# ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
		33	# include <semaphore.h>
		34	# endif
29	#elif defined(_LIBCPP_HAS_THREAD_API_C11)	35	#elif defined(_LIBCPP_HAS_THREAD_API_C11)
30	# include <threads.h>	36	# include <threads.h>
31	#endif	37	#endif
...	@@ -65,6 +71,12 @@ typedef pthread_mutex_t __libcpp_recursive_mutex_t;	...	@@ -65,6 +71,12 @@ typedef pthread_mutex_t __libcpp_recursive_mutex_t;
65	typedef pthread_cond_t __libcpp_condvar_t;	71	typedef pthread_cond_t __libcpp_condvar_t;
66	#define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER	72	#define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
67		73
		74	#ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
		75	// Semaphore
		76	typedef sem_t __libcpp_semaphore_t;
		77	# define _LIBCPP_SEMAPHORE_MAX SEM_VALUE_MAX
		78	#endif
		79
68	// Execute once	80	// Execute once
69	typedef pthread_once_t __libcpp_exec_once_flag;	81	typedef pthread_once_t __libcpp_exec_once_flag;
70	#define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT	82	#define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
...	@@ -127,6 +139,9 @@ typedef void* __libcpp_recursive_mutex_t[5];	...	@@ -127,6 +139,9 @@ typedef void* __libcpp_recursive_mutex_t[5];
127	typedef void* __libcpp_condvar_t;	139	typedef void* __libcpp_condvar_t;
128	#define _LIBCPP_CONDVAR_INITIALIZER 0	140	#define _LIBCPP_CONDVAR_INITIALIZER 0
129		141
		142	// Semaphore
		143	typedef void* __libcpp_semaphore_t;
		144
130	// Execute Once	145	// Execute Once
131	typedef void* __libcpp_exec_once_flag;	146	typedef void* __libcpp_exec_once_flag;
132	#define _LIBCPP_EXEC_ONCE_INITIALIZER 0	147	#define _LIBCPP_EXEC_ONCE_INITIALIZER 0
...	@@ -191,6 +206,26 @@ int __libcpp_condvar_timedwait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m,	...	@@ -191,6 +206,26 @@ int __libcpp_condvar_timedwait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m,
191	_LIBCPP_THREAD_ABI_VISIBILITY	206	_LIBCPP_THREAD_ABI_VISIBILITY
192	int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);	207	int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);
193		208
		209	#ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
		210
		211	// Semaphore
		212	_LIBCPP_THREAD_ABI_VISIBILITY
		213	bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init);
		214
		215	_LIBCPP_THREAD_ABI_VISIBILITY
		216	bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem);
		217
		218	_LIBCPP_THREAD_ABI_VISIBILITY
		219	bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem);
		220
		221	_LIBCPP_THREAD_ABI_VISIBILITY
		222	bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem);
		223
		224	_LIBCPP_THREAD_ABI_VISIBILITY
		225	bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns);
		226
		227	#endif // _LIBCPP_NO_NATIVE_SEMAPHORES
		228
194	// Execute once	229	// Execute once
195	_LIBCPP_THREAD_ABI_VISIBILITY	230	_LIBCPP_THREAD_ABI_VISIBILITY
196	int __libcpp_execute_once(__libcpp_exec_once_flag *flag,	231	int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
...	@@ -242,9 +277,52 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);	...	@@ -242,9 +277,52 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);
242		277
243	#endif // !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)	278	#endif // !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
244		279
		280	struct __libcpp_timed_backoff_policy {
		281	_LIBCPP_THREAD_ABI_VISIBILITY
		282	bool operator()(chrono::nanoseconds __elapsed) const;
		283	};
		284
		285	inline _LIBCPP_INLINE_VISIBILITY
		286	bool __libcpp_timed_backoff_policy::operator()(chrono::nanoseconds __elapsed) const
		287	{
		288	if(__elapsed > chrono::milliseconds(128))
		289	__libcpp_thread_sleep_for(chrono::milliseconds(8));
		290	else if(__elapsed > chrono::microseconds(64))
		291	__libcpp_thread_sleep_for(__elapsed / 2);
		292	else if(__elapsed > chrono::microseconds(4))
		293	__libcpp_thread_yield();
		294	else
		295	; // poll
		296	return false;
		297	}
		298
		299	static _LIBCPP_CONSTEXPR const int __libcpp_polling_count = 64;
		300
		301	template<class _Fn, class _BFn>
		302	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		303	bool __libcpp_thread_poll_with_backoff(
		304	_Fn && __f, _BFn && __bf, chrono::nanoseconds __max_elapsed = chrono::nanoseconds::zero())
		305	{
		306	auto const __start = chrono::high_resolution_clock::now();
		307	for(int __count = 0;;) {
		308	if(__f())
		309	return true; // _Fn completion means success
		310	if(__count < __libcpp_polling_count) {
		311	__count += 1;
		312	continue;
		313	}
		314	chrono::nanoseconds const __elapsed = chrono::high_resolution_clock::now() - __start;
		315	if(__max_elapsed != chrono::nanoseconds::zero() && __max_elapsed < __elapsed)
		316	return false; // timeout failure
		317	if(__bf(__elapsed))
		318	return false; // _BFn completion means failure
		319	}
		320	}
		321
245	#if (!defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \	322	#if (!defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \
246	defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL))	323	defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL))
247		324
		325
248	namespace __thread_detail {	326	namespace __thread_detail {
249		327
250	inline __libcpp_timespec_t __convert_to_timespec(const chrono::nanoseconds& __ns)	328	inline __libcpp_timespec_t __convert_to_timespec(const chrono::nanoseconds& __ns)
...	@@ -364,6 +442,38 @@ int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)	...	@@ -364,6 +442,38 @@ int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
364	return pthread_cond_destroy(__cv);	442	return pthread_cond_destroy(__cv);
365	}	443	}
366		444
		445	#ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
		446
		447	// Semaphore
		448	bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init)
		449	{
		450	return sem_init(__sem, 0, __init) == 0;
		451	}
		452
		453	bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem)
		454	{
		455	return sem_destroy(__sem) == 0;
		456	}
		457
		458	bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem)
		459	{
		460	return sem_post(__sem) == 0;
		461	}
		462
		463	bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem)
		464	{
		465	return sem_wait(__sem) == 0;
		466	}
		467
		468	bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns)
		469	{
		470	auto const __abs_time = chrono::system_clock::now().time_since_epoch() + __ns;
		471	__libcpp_timespec_t __ts = __thread_detail::__convert_to_timespec(__abs_time);
		472	return sem_timedwait(__sem, &__ts) == 0;
		473	}
		474
		475	#endif //_LIBCPP_NO_NATIVE_SEMAPHORES
		476
367	// Execute once	477	// Execute once
368	int __libcpp_execute_once(__libcpp_exec_once_flag *flag,	478	int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
369	void (*init_routine)()) {	479	void (*init_routine)()) {
...	@@ -600,6 +710,7 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)	...	@@ -600,6 +710,7 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
600		710
601	#endif	711	#endif
602		712
		713
603	#endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL \|\| _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL	714	#endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL \|\| _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL
604		715
605	class _LIBCPP_TYPE_VIS thread;	716	class _LIBCPP_TYPE_VIS thread;

lib/libcxx/include/array+144-101

 @@ -32,24 +32,24 @@ struct array
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // No explicit construct/copy/destroy for aggregate type
-    void fill(const T& u);
+    void fill(const T& u);                                      // constexpr in C++20
-    void swap(array& a) noexcept(is_nothrow_swappable_v<T>);
+    void swap(array& a) noexcept(is_nothrow_swappable_v<T>);    // constexpr in C++20
     // iterators:
-    iterator begin() noexcept;
+    iterator begin() noexcept;                                  // constexpr in C++17
-    const_iterator begin() const noexcept;
+    const_iterator begin() const noexcept;                      // constexpr in C++17
-    iterator end() noexcept;
+    iterator end() noexcept;                                    // constexpr in C++17
-    const_iterator end() const noexcept;
+    const_iterator end() const noexcept;                        // constexpr in C++17
-    reverse_iterator rbegin() noexcept;
+    reverse_iterator rbegin() noexcept;                         // constexpr in C++17
-    const_reverse_iterator rbegin() const noexcept;
+    const_reverse_iterator rbegin() const noexcept;             // constexpr in C++17
-    reverse_iterator rend() noexcept;
+    reverse_iterator rend() noexcept;                           // constexpr in C++17
-    const_reverse_iterator rend() const noexcept;
+    const_reverse_iterator rend() const noexcept;               // constexpr in C++17
-    const_iterator cbegin() const noexcept;
+    const_iterator cbegin() const noexcept;                     // constexpr in C++17
-    const_iterator cend() const noexcept;
+    const_iterator cend() const noexcept;                       // constexpr in C++17
-    const_reverse_iterator crbegin() const noexcept;
+    const_reverse_iterator crbegin() const noexcept;            // constexpr in C++17
-    const_reverse_iterator crend() const noexcept;
+    const_reverse_iterator crend() const noexcept;              // constexpr in C++17
     // capacity:
     constexpr size_type size() const noexcept;
 @@ -57,46 +57,51 @@ struct array
     constexpr bool empty() const noexcept;
     // element access:
-    reference operator[](size_type n);
+    reference operator[](size_type n);                          // constexpr in C++17
-    const_reference operator[](size_type n) const; // constexpr in C++14
+    const_reference operator[](size_type n) const;              // constexpr in C++14
-    const_reference at(size_type n) const; // constexpr in C++14
+    reference at(size_type n);                                  // constexpr in C++17
-    reference at(size_type n);
+    const_reference at(size_type n) const;                      // constexpr in C++14
-    reference front();
+    reference front();                                          // constexpr in C++17
-    const_reference front() const; // constexpr in C++14
+    const_reference front() const;                              // constexpr in C++14
-    reference back();
+    reference back();                                           // constexpr in C++17
-    const_reference back() const; // constexpr in C++14
+    const_reference back() const;                               // constexpr in C++14
-    T* data() noexcept;
+    T* data() noexcept;                                         // constexpr in C++17
-    const T* data() const noexcept;
+    const T* data() const noexcept;                             // constexpr in C++17
 };
-  template <class T, class... U>
+template <class T, class... U>
-    array(T, U...) -> array<T, 1 + sizeof...(U)>;
+  array(T, U...) -> array<T, 1 + sizeof...(U)>;                 // C++17
 template <class T, size_t N>
-  bool operator==(const array<T,N>& x, const array<T,N>& y);
+  bool operator==(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N>
-  bool operator!=(const array<T,N>& x, const array<T,N>& y);
+  bool operator!=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N>
-  bool operator<(const array<T,N>& x, const array<T,N>& y);
+  bool operator<(const array<T,N>& x, const array<T,N>& y);     // constexpr in C++20
 template <class T, size_t N>
-  bool operator>(const array<T,N>& x, const array<T,N>& y);
+  bool operator>(const array<T,N>& x, const array<T,N>& y);     // constexpr in C++20
 template <class T, size_t N>
-  bool operator<=(const array<T,N>& x, const array<T,N>& y);
+  bool operator<=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N>
-  bool operator>=(const array<T,N>& x, const array<T,N>& y);
+  bool operator>=(const array<T,N>& x, const array<T,N>& y);    // constexpr in C++20
 template <class T, size_t N >
-  void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); // C++17
+  void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y))); // constexpr in C++20
+template <class T, size_t N>
+  constexpr array<remove_cv_t<T>, N> to_array(T (&a)[N]);  // C++20
+template <class T, size_t N>
+  constexpr array<remove_cv_t<T>, N> to_array(T (&&a)[N]); // C++20
 template <class T> struct tuple_size;
 template <size_t I, class T> struct tuple_element;
 template <class T, size_t N> struct tuple_size<array<T, N>>;
 template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N>>;
-template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept; // constexpr in C++14
+template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept;               // constexpr in C++14
-template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept; // constexpr in C++14
+template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept;   // constexpr in C++14
-template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept; // constexpr in C++14
+template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept;             // constexpr in C++14
 template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14
 }  // std
 @@ -143,13 +148,14 @@ struct _LIBCPP_TEMPLATE_VIS array
     _Tp __elems_[_Size];
     // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) {
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-      _VSTD::fill_n(__elems_, _Size, __u);
+    void fill(const value_type& __u) {
+        _VSTD::fill_n(data(), _Size, __u);
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
-      std::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);
+        std::swap_ranges(data(), data() + _Size, __a.data());
     }
     // iterators:
 @@ -186,21 +192,38 @@ struct _LIBCPP_TEMPLATE_VIS array
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return false; }
+    _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;}
     // element access:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    reference operator[](size_type __n)             _NOEXCEPT {return __elems_[__n];}
+    reference operator[](size_type __n) _NOEXCEPT {
+        _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
+        return __elems_[__n];
+    }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    const_reference operator[](size_type __n) const _NOEXCEPT {return __elems_[__n];}
+    const_reference operator[](size_type __n) const _NOEXCEPT {
+        _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
+        return __elems_[__n];
+    }
-    _LIBCPP_CONSTEXPR_AFTER_CXX14       reference at(size_type __n);
+    _LIBCPP_CONSTEXPR_AFTER_CXX14 reference at(size_type __n)
-    _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const;
+    {
+        if (__n >= _Size)
+            __throw_out_of_range("array::at");
+        return __elems_[__n];
+    }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference front()             _NOEXCEPT {return __elems_[0];}
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const _NOEXCEPT {return __elems_[0];}
+    {
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back()              _NOEXCEPT {return __elems_[_Size - 1];}
+        if (__n >= _Size)
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const  _NOEXCEPT {return __elems_[_Size - 1];}
+            __throw_out_of_range("array::at");
+        return __elems_[__n];
+    }
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference front()             _NOEXCEPT {return (*this)[0];}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const _NOEXCEPT {return (*this)[0];}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back()              _NOEXCEPT {return (*this)[_Size - 1];}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const  _NOEXCEPT {return (*this)[_Size - 1];}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     value_type* data() _NOEXCEPT {return __elems_;}
 @@ -208,28 +231,6 @@ struct _LIBCPP_TEMPLATE_VIS array
     const value_type* data() const _NOEXCEPT {return __elems_;}
 };
-template <class _Tp, size_t _Size>
-_LIBCPP_CONSTEXPR_AFTER_CXX14
-typename array<_Tp, _Size>::reference
-array<_Tp, _Size>::at(size_type __n)
-{
-    if (__n >= _Size)
-        __throw_out_of_range("array::at");
-    return __elems_[__n];
-}
-template <class _Tp, size_t _Size>
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-typename array<_Tp, _Size>::const_reference
-array<_Tp, _Size>::at(size_type __n) const
-{
-    if (__n >= _Size)
-        __throw_out_of_range("array::at");
-    return __elems_[__n];
-}
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
 {
 @@ -253,44 +254,50 @@ struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
     struct  _ArrayInStructT { _Tp __data_[1]; };
     _ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    value_type* data() _NOEXCEPT {return nullptr;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    const value_type* data() const _NOEXCEPT {return nullptr;}
     // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY void fill(const value_type&) {
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    void fill(const value_type&) {
       static_assert(!is_const<_Tp>::value,
                     "cannot fill zero-sized array of type 'const T'");
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(array&) _NOEXCEPT {
       static_assert(!is_const<_Tp>::value,
                     "cannot swap zero-sized array of type 'const T'");
     }
     // iterators:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     iterator begin() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     iterator end() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator end() const _NOEXCEPT {return const_iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
     // capacity:
 @@ -302,7 +309,7 @@ struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
     _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;}
     // element access:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator[](size_type) _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
       _LIBCPP_UNREACHABLE();
 @@ -314,52 +321,47 @@ struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
       _LIBCPP_UNREACHABLE();
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference at(size_type) {
       __throw_out_of_range("array<T, 0>::at");
       _LIBCPP_UNREACHABLE();
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference at(size_type) const {
       __throw_out_of_range("array<T, 0>::at");
       _LIBCPP_UNREACHABLE();
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference front() _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference front() const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference back() _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference back() const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
       _LIBCPP_UNREACHABLE();
     }
-    _LIBCPP_INLINE_VISIBILITY
-    value_type* data() _NOEXCEPT {return reinterpret_cast<value_type*>(__elems_);}
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type* data() const _NOEXCEPT {return reinterpret_cast<const value_type*>(__elems_);}
 };
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template<class _Tp, class... _Args,
-         class = typename enable_if<(is_same_v<_Tp, _Args> && ...), void>::type
+         class = _EnableIf<__all<_IsSame<_Tp, _Args>::value...>::value>
          >
 array(_Tp, _Args...)
   -> array<_Tp, 1 + sizeof...(_Args)>;
 @@ -415,7 +417,7 @@ operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 }
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     _Size == 0 ||
 @@ -479,6 +481,47 @@ get(const array<_Tp, _Size>&& __a) _NOEXCEPT
 #endif  // !_LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER > 17
+template <typename _Tp, size_t _Size, size_t... _Index>
+_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
+__to_array_lvalue_impl(_Tp (&__arr)[_Size], index_sequence<_Index...>) {
+  return {{__arr[_Index]...}};
+}
+template <typename _Tp, size_t _Size, size_t... _Index>
+_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
+__to_array_rvalue_impl(_Tp(&&__arr)[_Size], index_sequence<_Index...>) {
+  return {{_VSTD::move(__arr[_Index])...}};
+}
+template <typename _Tp, size_t _Size>
+_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
+to_array(_Tp (&__arr)[_Size]) noexcept(is_nothrow_constructible_v<_Tp, _Tp&>) {
+  static_assert(
+      !is_array_v<_Tp>,
+      "[array.creation]/1: to_array does not accept multidimensional arrays.");
+  static_assert(
+      is_constructible_v<_Tp, _Tp&>,
+      "[array.creation]/1: to_array requires copy constructible elements.");
+  return __to_array_lvalue_impl(__arr, make_index_sequence<_Size>());
+}
+template <typename _Tp, size_t _Size>
+_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
+to_array(_Tp(&&__arr)[_Size]) noexcept(is_nothrow_move_constructible_v<_Tp>) {
+  static_assert(
+      !is_array_v<_Tp>,
+      "[array.creation]/4: to_array does not accept multidimensional arrays.");
+  static_assert(
+      is_move_constructible_v<_Tp>,
+      "[array.creation]/4: to_array requires move constructible elements.");
+  return __to_array_rvalue_impl(_VSTD::move(__arr),
+                                make_index_sequence<_Size>());
+}
+#endif // _LIBCPP_STD_VER > 17
 _LIBCPP_END_NAMESPACE_STD
 #endif  // _LIBCPP_ARRAY

lib/libcxx/include/atomic+553-207

...	@@ -54,60 +54,30 @@ template <class T> T kill_dependency(T y) noexcept;	...	@@ -54,60 +54,30 @@ template <class T> T kill_dependency(T y) noexcept;
54	#define ATOMIC_LLONG_LOCK_FREE unspecified	54	#define ATOMIC_LLONG_LOCK_FREE unspecified
55	#define ATOMIC_POINTER_LOCK_FREE unspecified	55	#define ATOMIC_POINTER_LOCK_FREE unspecified
56		56
57	// flag type and operations
58
59	typedef struct atomic_flag
60	{
61	bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept;
62	bool test_and_set(memory_order m = memory_order_seq_cst) noexcept;
63	void clear(memory_order m = memory_order_seq_cst) volatile noexcept;
64	void clear(memory_order m = memory_order_seq_cst) noexcept;
65	atomic_flag() noexcept = default;
66	atomic_flag(const atomic_flag&) = delete;
67	atomic_flag& operator=(const atomic_flag&) = delete;
68	atomic_flag& operator=(const atomic_flag&) volatile = delete;
69	} atomic_flag;
70
71	bool
72	atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept;
73
74	bool
75	atomic_flag_test_and_set(atomic_flag* obj) noexcept;
76
77	bool
78	atomic_flag_test_and_set_explicit(volatile atomic_flag* obj,
79	memory_order m) noexcept;
80
81	bool
82	atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept;
83
84	void
85	atomic_flag_clear(volatile atomic_flag* obj) noexcept;
86
87	void
88	atomic_flag_clear(atomic_flag* obj) noexcept;
89
90	void
91	atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexcept;
92
93	void
94	atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept;
95
96	#define ATOMIC_FLAG_INIT see below
97	#define ATOMIC_VAR_INIT(value) see below
98
99	template <class T>	57	template <class T>
100	struct atomic	58	struct atomic
101	{	59	{
		60	using value_type = T;
		61
102	static constexpr bool is_always_lock_free;	62	static constexpr bool is_always_lock_free;
103	bool is_lock_free() const volatile noexcept;	63	bool is_lock_free() const volatile noexcept;
104	bool is_lock_free() const noexcept;	64	bool is_lock_free() const noexcept;
105	void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;	65
106	void store(T desr, memory_order m = memory_order_seq_cst) noexcept;	66	atomic() noexcept = default;
		67	constexpr atomic(T desr) noexcept;
		68	atomic(const atomic&) = delete;
		69	atomic& operator=(const atomic&) = delete;
		70	atomic& operator=(const atomic&) volatile = delete;
		71
107	T load(memory_order m = memory_order_seq_cst) const volatile noexcept;	72	T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
108	T load(memory_order m = memory_order_seq_cst) const noexcept;	73	T load(memory_order m = memory_order_seq_cst) const noexcept;
109	operator T() const volatile noexcept;	74	operator T() const volatile noexcept;
110	operator T() const noexcept;	75	operator T() const noexcept;
		76	void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
		77	void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
		78	T operator=(T) volatile noexcept;
		79	T operator=(T) noexcept;
		80
111	T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;	81	T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
112	T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;	82	T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;
113	bool compare_exchange_weak(T& expc, T desr,	83	bool compare_exchange_weak(T& expc, T desr,
...	@@ -126,27 +96,38 @@ struct atomic	...	@@ -126,27 +96,38 @@ struct atomic
126	bool compare_exchange_strong(T& expc, T desr,	96	bool compare_exchange_strong(T& expc, T desr,
127	memory_order m = memory_order_seq_cst) noexcept;	97	memory_order m = memory_order_seq_cst) noexcept;
128		98
129	atomic() noexcept = default;	99	void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
130	constexpr atomic(T desr) noexcept;	100	void wait(T, memory_order = memory_order::seq_cst) const noexcept;
131	atomic(const atomic&) = delete;	101	void notify_one() volatile noexcept;
132	atomic& operator=(const atomic&) = delete;	102	void notify_one() noexcept;
133	atomic& operator=(const atomic&) volatile = delete;	103	void notify_all() volatile noexcept;
134	T operator=(T) volatile noexcept;	104	void notify_all() noexcept;
135	T operator=(T) noexcept;
136	};	105	};
137		106
138	template <>	107	template <>
139	struct atomic<integral>	108	struct atomic<integral>
140	{	109	{
		110	using value_type = integral;
		111
141	static constexpr bool is_always_lock_free;	112	static constexpr bool is_always_lock_free;
142	bool is_lock_free() const volatile noexcept;	113	bool is_lock_free() const volatile noexcept;
143	bool is_lock_free() const noexcept;	114	bool is_lock_free() const noexcept;
144	void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;	115
145	void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;	116	atomic() noexcept = default;
		117	constexpr atomic(integral desr) noexcept;
		118	atomic(const atomic&) = delete;
		119	atomic& operator=(const atomic&) = delete;
		120	atomic& operator=(const atomic&) volatile = delete;
		121
146	integral load(memory_order m = memory_order_seq_cst) const volatile noexcept;	122	integral load(memory_order m = memory_order_seq_cst) const volatile noexcept;
147	integral load(memory_order m = memory_order_seq_cst) const noexcept;	123	integral load(memory_order m = memory_order_seq_cst) const noexcept;
148	operator integral() const volatile noexcept;	124	operator integral() const volatile noexcept;
149	operator integral() const noexcept;	125	operator integral() const noexcept;
		126	void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
		127	void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;
		128	integral operator=(integral desr) volatile noexcept;
		129	integral operator=(integral desr) noexcept;
		130
150	integral exchange(integral desr,	131	integral exchange(integral desr,
151	memory_order m = memory_order_seq_cst) volatile noexcept;	132	memory_order m = memory_order_seq_cst) volatile noexcept;
152	integral exchange(integral desr, memory_order m = memory_order_seq_cst) noexcept;	133	integral exchange(integral desr, memory_order m = memory_order_seq_cst) noexcept;
...	@@ -167,30 +148,17 @@ struct atomic<integral>	...	@@ -167,30 +148,17 @@ struct atomic<integral>
167	bool compare_exchange_strong(integral& expc, integral desr,	148	bool compare_exchange_strong(integral& expc, integral desr,
168	memory_order m = memory_order_seq_cst) noexcept;	149	memory_order m = memory_order_seq_cst) noexcept;
169		150
170	integral	151	integral fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
171	fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
172	integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexcept;	152	integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexcept;
173	integral	153	integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
174	fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
175	integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexcept;	154	integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexcept;
176	integral	155	integral fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
177	fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
178	integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexcept;	156	integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexcept;
179	integral	157	integral fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
180	fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
181	integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept;	158	integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept;
182	integral	159	integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
183	fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
184	integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept;	160	integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept;
185		161
186	atomic() noexcept = default;
187	constexpr atomic(integral desr) noexcept;
188	atomic(const atomic&) = delete;
189	atomic& operator=(const atomic&) = delete;
190	atomic& operator=(const atomic&) volatile = delete;
191	integral operator=(integral desr) volatile noexcept;
192	integral operator=(integral desr) noexcept;
193
194	integral operator++(int) volatile noexcept;	162	integral operator++(int) volatile noexcept;
195	integral operator++(int) noexcept;	163	integral operator++(int) noexcept;
196	integral operator--(int) volatile noexcept;	164	integral operator--(int) volatile noexcept;
...	@@ -209,20 +177,39 @@ struct atomic<integral>	...	@@ -209,20 +177,39 @@ struct atomic<integral>
209	integral operator\|=(integral op) noexcept;	177	integral operator\|=(integral op) noexcept;
210	integral operator^=(integral op) volatile noexcept;	178	integral operator^=(integral op) volatile noexcept;
211	integral operator^=(integral op) noexcept;	179	integral operator^=(integral op) noexcept;
		180
		181	void wait(integral, memory_order = memory_order::seq_cst) const volatile noexcept;
		182	void wait(integral, memory_order = memory_order::seq_cst) const noexcept;
		183	void notify_one() volatile noexcept;
		184	void notify_one() noexcept;
		185	void notify_all() volatile noexcept;
		186	void notify_all() noexcept;
212	};	187	};
213		188
214	template <class T>	189	template <class T>
215	struct atomic<T*>	190	struct atomic<T*>
216	{	191	{
		192	using value_type = T*;
		193
217	static constexpr bool is_always_lock_free;	194	static constexpr bool is_always_lock_free;
218	bool is_lock_free() const volatile noexcept;	195	bool is_lock_free() const volatile noexcept;
219	bool is_lock_free() const noexcept;	196	bool is_lock_free() const noexcept;
220	void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;	197
221	void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;	198	atomic() noexcept = default;
		199	constexpr atomic(T* desr) noexcept;
		200	atomic(const atomic&) = delete;
		201	atomic& operator=(const atomic&) = delete;
		202	atomic& operator=(const atomic&) volatile = delete;
		203
222	T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;	204	T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;
223	T* load(memory_order m = memory_order_seq_cst) const noexcept;	205	T* load(memory_order m = memory_order_seq_cst) const noexcept;
224	operator T*() const volatile noexcept;	206	operator T*() const volatile noexcept;
225	operator T*() const noexcept;	207	operator T*() const noexcept;
		208	void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
		209	void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;
		210	T* operator=(T*) volatile noexcept;
		211	T* operator=(T*) noexcept;
		212
226	T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;	213	T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
227	T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept;	214	T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept;
228	bool compare_exchange_weak(T& expc, T desr,	215	bool compare_exchange_weak(T& expc, T desr,
...	@@ -246,14 +233,6 @@ struct atomic<T*>	...	@@ -246,14 +233,6 @@ struct atomic<T*>
246	T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;	233	T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;
247	T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;	234	T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
248		235
249	atomic() noexcept = default;
250	constexpr atomic(T* desr) noexcept;
251	atomic(const atomic&) = delete;
252	atomic& operator=(const atomic&) = delete;
253	atomic& operator=(const atomic&) volatile = delete;
254
255	T* operator=(T*) volatile noexcept;
256	T* operator=(T*) noexcept;
257	T* operator++(int) volatile noexcept;	236	T* operator++(int) volatile noexcept;
258	T* operator++(int) noexcept;	237	T* operator++(int) noexcept;
259	T* operator--(int) volatile noexcept;	238	T* operator--(int) volatile noexcept;
...	@@ -266,224 +245,206 @@ struct atomic<T*>	...	@@ -266,224 +245,206 @@ struct atomic<T*>
266	T* operator+=(ptrdiff_t op) noexcept;	245	T* operator+=(ptrdiff_t op) noexcept;
267	T* operator-=(ptrdiff_t op) volatile noexcept;	246	T* operator-=(ptrdiff_t op) volatile noexcept;
268	T* operator-=(ptrdiff_t op) noexcept;	247	T* operator-=(ptrdiff_t op) noexcept;
		248
		249	void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
		250	void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
		251	void notify_one() volatile noexcept;
		252	void notify_one() noexcept;
		253	void notify_all() volatile noexcept;
		254	void notify_all() noexcept;
269	};	255	};
270		256
271		257
272	template <class T>	258	template <class T>
273	bool	259	bool atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;
274	atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;	260
		261	template <class T>
		262	bool atomic_is_lock_free(const atomic<T>* obj) noexcept;
		263
		264	template <class T>
		265	void atomic_store(volatile atomic<T>* obj, T desr) noexcept;
		266
		267	template <class T>
		268	void atomic_store(atomic<T>* obj, T desr) noexcept;
		269
		270	template <class T>
		271	void atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
		272
		273	template <class T>
		274	void atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
		275
		276	template <class T>
		277	T atomic_load(const volatile atomic<T>* obj) noexcept;
275		278
276	template <class T>	279	template <class T>
277	bool	280	T atomic_load(const atomic<T>* obj) noexcept;
278	atomic_is_lock_free(const atomic<T>* obj) noexcept;
279		281
280	template <class T>	282	template <class T>
281	void	283	T atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept;
282	atomic_init(volatile atomic<T>* obj, T desr) noexcept;
283		284
284	template <class T>	285	template <class T>
285	void	286	T atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept;
286	atomic_init(atomic<T>* obj, T desr) noexcept;
287		287
288	template <class T>	288	template <class T>
289	void	289	T atomic_exchange(volatile atomic<T>* obj, T desr) noexcept;
290	atomic_store(volatile atomic<T>* obj, T desr) noexcept;
291		290
292	template <class T>	291	template <class T>
293	void	292	T atomic_exchange(atomic<T>* obj, T desr) noexcept;
294	atomic_store(atomic<T>* obj, T desr) noexcept;
295		293
296	template <class T>	294	template <class T>
297	void	295	T atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
298	atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
299		296
300	template <class T>	297	template <class T>
301	void	298	T atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
302	atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
303		299
304	template <class T>	300	template <class T>
305	T	301	bool atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept;
306	atomic_load(const volatile atomic<T>* obj) noexcept;
307		302
308	template <class T>	303	template <class T>
309	T	304	bool atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept;
310	atomic_load(const atomic<T>* obj) noexcept;
311		305
312	template <class T>	306	template <class T>
313	T	307	bool atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept;
314	atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept;
315		308
316	template <class T>	309	template <class T>
317	T	310	bool atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept;
318	atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept;
319		311
320	template <class T>	312	template <class T>
321	T	313	bool atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
322	atomic_exchange(volatile atomic<T>* obj, T desr) noexcept;	314	T desr,
		315	memory_order s, memory_order f) noexcept;
323		316
324	template <class T>	317	template <class T>
325	T	318	bool atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
326	atomic_exchange(atomic<T>* obj, T desr) noexcept;	319	memory_order s, memory_order f) noexcept;
327		320
328	template <class T>	321	template <class T>
329	T	322	bool atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
330	atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;	323	T* expc, T desr,
		324	memory_order s, memory_order f) noexcept;
331		325
332	template <class T>	326	template <class T>
333	T	327	bool atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
334	atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;	328	T desr,
		329	memory_order s, memory_order f) noexcept;
335		330
336	template <class T>	331	template <class T>
337	bool	332	void atomic_wait(const volatile atomic<T>* obj, T old) noexcept;
338	atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept;
339		333
340	template <class T>	334	template <class T>
341	bool	335	void atomic_wait(const atomic<T>* obj, T old) noexcept;
342	atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept;
343		336
344	template <class T>	337	template <class T>
345	bool	338	void atomic_wait_explicit(const volatile atomic<T>* obj, T old, memory_order m) noexcept;
346	atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept;
347		339
348	template <class T>	340	template <class T>
349	bool	341	void atomic_wait_explicit(const atomic<T>* obj, T old, memory_order m) noexcept;
350	atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept;
351		342
352	template <class T>	343	template <class T>
353	bool	344	void atomic_one(volatile atomic<T>* obj) noexcept;
354	atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
355	T desr,
356	memory_order s, memory_order f) noexcept;
357		345
358	template <class T>	346	template <class T>
359	bool	347	void atomic_one(atomic<T>* obj) noexcept;
360	atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
361	memory_order s, memory_order f) noexcept;
362		348
363	template <class T>	349	template <class T>
364	bool	350	void atomic_all(volatile atomic<T>* obj) noexcept;
365	atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
366	T* expc, T desr,
367	memory_order s, memory_order f) noexcept;
368		351
369	template <class T>	352	template <class T>
370	bool	353	void atomic_all(atomic<T>* obj) noexcept;
371	atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
372	T desr,
373	memory_order s, memory_order f) noexcept;
374		354
375	template <class Integral>	355	template <class Integral>
376	Integral	356	Integral atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept;
377	atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept;
378		357
379	template <class Integral>	358	template <class Integral>
380	Integral	359	Integral atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept;
381	atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept;
382		360
383	template <class Integral>	361	template <class Integral>
384	Integral	362	Integral atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
385	atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
386	memory_order m) noexcept;	363	memory_order m) noexcept;
387	template <class Integral>	364	template <class Integral>
388	Integral	365	Integral atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
389	atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
390	memory_order m) noexcept;	366	memory_order m) noexcept;
391	template <class Integral>	367	template <class Integral>
392	Integral	368	Integral atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept;
393	atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept;
394		369
395	template <class Integral>	370	template <class Integral>
396	Integral	371	Integral atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept;
397	atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept;
398		372
399	template <class Integral>	373	template <class Integral>
400	Integral	374	Integral atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
401	atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,	375	memory_order m) noexcept;
402	memory_order m) noexcept;	376
403	template <class Integral>	377	template <class Integral>
404	Integral	378	Integral atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
405	atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,	379	memory_order m) noexcept;
406	memory_order m) noexcept;	380
407	template <class Integral>	381	template <class Integral>
408	Integral	382	Integral atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept;
409	atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept;
410		383
411	template <class Integral>	384	template <class Integral>
412	Integral	385	Integral atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept;
413	atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept;
414		386
415	template <class Integral>	387	template <class Integral>
416	Integral	388	Integral atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,
417	atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,	389	memory_order m) noexcept;
418	memory_order m) noexcept;	390
419	template <class Integral>	391	template <class Integral>
420	Integral	392	Integral atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,
421	atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,	393	memory_order m) noexcept;
422	memory_order m) noexcept;	394
423	template <class Integral>	395	template <class Integral>
424	Integral	396	Integral atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept;
425	atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept;
426		397
427	template <class Integral>	398	template <class Integral>
428	Integral	399	Integral atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept;
429	atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept;
430		400
431	template <class Integral>	401	template <class Integral>
432	Integral	402	Integral atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
433	atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
434	memory_order m) noexcept;	403	memory_order m) noexcept;
		404
435	template <class Integral>	405	template <class Integral>
436	Integral	406	Integral atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
437	atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
438	memory_order m) noexcept;	407	memory_order m) noexcept;
		408
439	template <class Integral>	409	template <class Integral>
440	Integral	410	Integral atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept;
441	atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept;
442		411
443	template <class Integral>	412	template <class Integral>
444	Integral	413	Integral atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept;
445	atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept;
446		414
447	template <class Integral>	415	template <class Integral>
448	Integral	416	Integral atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,
449	atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,	417	memory_order m) noexcept;
450	memory_order m) noexcept;	418
451	template <class Integral>	419	template <class Integral>
452	Integral	420	Integral atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,
453	atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,	421	memory_order m) noexcept;
454	memory_order m) noexcept;
455		422
456	template <class T>	423	template <class T>
457	T*	424	T* atomic_fetch_add(volatile atomic<T> obj, ptrdiff_t op) noexcept;
458	atomic_fetch_add(volatile atomic<T> obj, ptrdiff_t op) noexcept;
459		425
460	template <class T>	426	template <class T>
461	T*	427	T* atomic_fetch_add(atomic<T> obj, ptrdiff_t op) noexcept;
462	atomic_fetch_add(atomic<T> obj, ptrdiff_t op) noexcept;
463		428
464	template <class T>	429	template <class T>
465	T*	430	T* atomic_fetch_add_explicit(volatile atomic<T> obj, ptrdiff_t op,
466	atomic_fetch_add_explicit(volatile atomic<T> obj, ptrdiff_t op,	431	memory_order m) noexcept;
467	memory_order m) noexcept;	432
468	template <class T>	433	template <class T>
469	T*	434	T* atomic_fetch_add_explicit(atomic<T> obj, ptrdiff_t op, memory_order m) noexcept;
470	atomic_fetch_add_explicit(atomic<T> obj, ptrdiff_t op, memory_order m) noexcept;
471		435
472	template <class T>	436	template <class T>
473	T*	437	T* atomic_fetch_sub(volatile atomic<T> obj, ptrdiff_t op) noexcept;
474	atomic_fetch_sub(volatile atomic<T> obj, ptrdiff_t op) noexcept;
475		438
476	template <class T>	439	template <class T>
477	T*	440	T* atomic_fetch_sub(atomic<T> obj, ptrdiff_t op) noexcept;
478	atomic_fetch_sub(atomic<T> obj, ptrdiff_t op) noexcept;
479		441
480	template <class T>	442	template <class T>
481	T*	443	T* atomic_fetch_sub_explicit(volatile atomic<T> obj, ptrdiff_t op,
482	atomic_fetch_sub_explicit(volatile atomic<T> obj, ptrdiff_t op,	444	memory_order m) noexcept;
483	memory_order m) noexcept;	445
484	template <class T>	446	template <class T>
485	T*	447	T* atomic_fetch_sub_explicit(atomic<T> obj, ptrdiff_t op, memory_order m) noexcept;
486	atomic_fetch_sub_explicit(atomic<T> obj, ptrdiff_t op, memory_order m) noexcept;
487		448
488	// Atomics for standard typedef types	449	// Atomics for standard typedef types
489		450
...	@@ -516,7 +477,7 @@ typedef atomic<int_fast8_t> atomic_int_fast8_t;	...	@@ -516,7 +477,7 @@ typedef atomic<int_fast8_t> atomic_int_fast8_t;
516	typedef atomic<uint_fast8_t> atomic_uint_fast8_t;	477	typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
517	typedef atomic<int_fast16_t> atomic_int_fast16_t;	478	typedef atomic<int_fast16_t> atomic_int_fast16_t;
518	typedef atomic<uint_fast16_t> atomic_uint_fast16_t;	479	typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
519	typedef atomic<int_fast32_t> atomic_int_fast32_t;	480	typedef atomic<int_fast32_t> atomic_int_fast32_t;
520	typedef atomic<uint_fast32_t> atomic_uint_fast32_t;	481	typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
521	typedef atomic<int_fast64_t> atomic_int_fast64_t;	482	typedef atomic<int_fast64_t> atomic_int_fast64_t;
522	typedef atomic<uint_fast64_t> atomic_uint_fast64_t;	483	typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
...	@@ -537,18 +498,80 @@ typedef atomic<ptrdiff_t> atomic_ptrdiff_t;	...	@@ -537,18 +498,80 @@ typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
537	typedef atomic<intmax_t> atomic_intmax_t;	498	typedef atomic<intmax_t> atomic_intmax_t;
538	typedef atomic<uintmax_t> atomic_uintmax_t;	499	typedef atomic<uintmax_t> atomic_uintmax_t;
539		500
		501	// flag type and operations
		502
		503	typedef struct atomic_flag
		504	{
		505	atomic_flag() noexcept = default;
		506	atomic_flag(const atomic_flag&) = delete;
		507	atomic_flag& operator=(const atomic_flag&) = delete;
		508	atomic_flag& operator=(const atomic_flag&) volatile = delete;
		509
		510	bool test(memory_order m = memory_order_seq_cst) volatile noexcept;
		511	bool test(memory_order m = memory_order_seq_cst) noexcept;
		512	bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept;
		513	bool test_and_set(memory_order m = memory_order_seq_cst) noexcept;
		514	void clear(memory_order m = memory_order_seq_cst) volatile noexcept;
		515	void clear(memory_order m = memory_order_seq_cst) noexcept;
		516
		517	void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept;
		518	void wait(bool, memory_order = memory_order::seq_cst) const noexcept;
		519	void notify_one() volatile noexcept;
		520	void notify_one() noexcept;
		521	void notify_all() volatile noexcept;
		522	void notify_all() noexcept;
		523	} atomic_flag;
		524
		525	bool atomic_flag_test(volatile atomic_flag* obj) noexcept;
		526	bool atomic_flag_test(atomic_flag* obj) noexcept;
		527	bool atomic_flag_test_explicit(volatile atomic_flag* obj,
		528	memory_order m) noexcept;
		529	bool atomic_flag_test_explicit(atomic_flag* obj, memory_order m) noexcept;
		530	bool atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept;
		531	bool atomic_flag_test_and_set(atomic_flag* obj) noexcept;
		532	bool atomic_flag_test_and_set_explicit(volatile atomic_flag* obj,
		533	memory_order m) noexcept;
		534	bool atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept;
		535	void atomic_flag_clear(volatile atomic_flag* obj) noexcept;
		536	void atomic_flag_clear(atomic_flag* obj) noexcept;
		537	void atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexcept;
		538	void atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept;
		539
		540	void atomic_wait(const volatile atomic_flag* obj, T old) noexcept;
		541	void atomic_wait(const atomic_flag* obj, T old) noexcept;
		542	void atomic_wait_explicit(const volatile atomic_flag* obj, T old, memory_order m) noexcept;
		543	void atomic_wait_explicit(const atomic_flag* obj, T old, memory_order m) noexcept;
		544	void atomic_one(volatile atomic_flag* obj) noexcept;
		545	void atomic_one(atomic_flag* obj) noexcept;
		546	void atomic_all(volatile atomic_flag* obj) noexcept;
		547	void atomic_all(atomic_flag* obj) noexcept;
		548
540	// fences	549	// fences
541		550
542	void atomic_thread_fence(memory_order m) noexcept;	551	void atomic_thread_fence(memory_order m) noexcept;
543	void atomic_signal_fence(memory_order m) noexcept;	552	void atomic_signal_fence(memory_order m) noexcept;
544		553
		554	// deprecated
		555
		556	template <class T>
		557	void atomic_init(volatile atomic<T>* obj, typename atomic<T>::value_type desr) noexcept;
		558
		559	template <class T>
		560	void atomic_init(atomic<T>* obj, typename atomic<T>::value_type desr) noexcept;
		561
		562	#define ATOMIC_VAR_INIT(value) see below
		563
		564	#define ATOMIC_FLAG_INIT see below
		565
545	} // std	566	} // std
546		567
547	*/	568	*/
548		569
549	#include <__config>	570	#include <__config>
		571	#include <__threading_support>
550	#include <cstddef>	572	#include <cstddef>
551	#include <cstdint>	573	#include <cstdint>
		574	#include <cstring>
552	#include <type_traits>	575	#include <type_traits>
553	#include <version>	576	#include <version>
554		577
...	@@ -629,6 +652,11 @@ typedef enum memory_order {	...	@@ -629,6 +652,11 @@ typedef enum memory_order {
629		652
630	#endif // _LIBCPP_STD_VER > 17	653	#endif // _LIBCPP_STD_VER > 17
631		654
		655	template <typename _Tp> _LIBCPP_INLINE_VISIBILITY
		656	bool __cxx_nonatomic_compare_equal(_Tp const& __lhs, _Tp const& __rhs) {
		657	return memcmp(&__lhs, &__rhs, sizeof(_Tp)) == 0;
		658	}
		659
632	static_assert((is_same<underlying_type<memory_order>::type, __memory_order_underlying_t>::value),	660	static_assert((is_same<underlying_type<memory_order>::type, __memory_order_underlying_t>::value),
633	"unexpected underlying type for std::memory_order");	661	"unexpected underlying type for std::memory_order");
634		662
...	@@ -1218,9 +1246,9 @@ _LIBCPP_INLINE_VISIBILITY	...	@@ -1218,9 +1246,9 @@ _LIBCPP_INLINE_VISIBILITY
1218	bool __cxx_atomic_compare_exchange_strong(volatile __cxx_atomic_lock_impl<_Tp>* __a,	1246	bool __cxx_atomic_compare_exchange_strong(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1219	_Tp* __expected, _Tp __value, memory_order, memory_order) {	1247	_Tp* __expected, _Tp __value, memory_order, memory_order) {
1220	__a->__lock();	1248	__a->__lock();
1221	_Tp temp;	1249	_Tp __temp;
1222	__cxx_atomic_assign_volatile(temp, __a->__a_value);	1250	__cxx_atomic_assign_volatile(__temp, __a->__a_value);
1223	bool __ret = temp == *__expected;	1251	bool __ret = __temp == *__expected;
1224	if(__ret)	1252	if(__ret)
1225	__cxx_atomic_assign_volatile(__a->__a_value, __value);	1253	__cxx_atomic_assign_volatile(__a->__a_value, __value);
1226	else	1254	else
...	@@ -1247,9 +1275,9 @@ _LIBCPP_INLINE_VISIBILITY	...	@@ -1247,9 +1275,9 @@ _LIBCPP_INLINE_VISIBILITY
1247	bool __cxx_atomic_compare_exchange_weak(volatile __cxx_atomic_lock_impl<_Tp>* __a,	1275	bool __cxx_atomic_compare_exchange_weak(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1248	_Tp* __expected, _Tp __value, memory_order, memory_order) {	1276	_Tp* __expected, _Tp __value, memory_order, memory_order) {
1249	__a->__lock();	1277	__a->__lock();
1250	_Tp temp;	1278	_Tp __temp;
1251	__cxx_atomic_assign_volatile(temp, __a->__a_value);	1279	__cxx_atomic_assign_volatile(__temp, __a->__a_value);
1252	bool __ret = temp == *__expected;	1280	bool __ret = __temp == *__expected;
1253	if(__ret)	1281	if(__ret)
1254	__cxx_atomic_assign_volatile(__a->__a_value, __value);	1282	__cxx_atomic_assign_volatile(__a->__a_value, __value);
1255	else	1283	else
...	@@ -1452,6 +1480,93 @@ struct __cxx_atomic_impl : public _Base {	...	@@ -1452,6 +1480,93 @@ struct __cxx_atomic_impl : public _Base {
1452	: _Base(value) {}	1480	: _Base(value) {}
1453	};	1481	};
1454		1482
		1483	#ifdef __linux__
		1484	using __cxx_contention_t = int32_t;
		1485	#else
		1486	using __cxx_contention_t = int64_t;
		1487	#endif //__linux__
		1488
		1489	#if _LIBCPP_STD_VER >= 11
		1490
		1491	using __cxx_atomic_contention_t = __cxx_atomic_impl<__cxx_contention_t>;
		1492
		1493	#ifndef _LIBCPP_HAS_NO_PLATFORM_WAIT
		1494
		1495	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile*);
		1496	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile*);
		1497	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(void const volatile*);
		1498	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __libcpp_atomic_wait(void const volatile*, __cxx_contention_t);
		1499
		1500	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile*);
		1501	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile*);
		1502	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile*);
		1503	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __libcpp_atomic_wait(__cxx_atomic_contention_t const volatile*, __cxx_contention_t);
		1504
		1505	template <class _Atp, class _Fn>
		1506	struct __libcpp_atomic_wait_backoff_impl {
		1507	_Atp* __a;
		1508	_Fn __test_fn;
		1509	_LIBCPP_AVAILABILITY_SYNC
		1510	_LIBCPP_INLINE_VISIBILITY bool operator()(chrono::nanoseconds __elapsed) const
		1511	{
		1512	if(__elapsed > chrono::microseconds(64))
		1513	{
		1514	auto const __monitor = __libcpp_atomic_monitor(__a);
		1515	if(__test_fn())
		1516	return true;
		1517	__libcpp_atomic_wait(__a, __monitor);
		1518	}
		1519	else if(__elapsed > chrono::microseconds(4))
		1520	__libcpp_thread_yield();
		1521	else
		1522	; // poll
		1523	return false;
		1524	}
		1525	};
		1526
		1527	template <class _Atp, class _Fn>
		1528	_LIBCPP_AVAILABILITY_SYNC
		1529	_LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_wait(_Atp* __a, _Fn && __test_fn)
		1530	{
		1531	__libcpp_atomic_wait_backoff_impl<_Atp, typename decay<_Fn>::type> __backoff_fn = {__a, __test_fn};
		1532	return __libcpp_thread_poll_with_backoff(__test_fn, __backoff_fn);
		1533	}
		1534
		1535	#else // _LIBCPP_HAS_NO_PLATFORM_WAIT
		1536
		1537	template <class _Tp>
		1538	_LIBCPP_INLINE_VISIBILITY void __cxx_atomic_notify_all(__cxx_atomic_impl<_Tp> const volatile*) { }
		1539	template <class _Tp>
		1540	_LIBCPP_INLINE_VISIBILITY void __cxx_atomic_notify_one(__cxx_atomic_impl<_Tp> const volatile*) { }
		1541	template <class _Atp, class _Fn>
		1542	_LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_wait(_Atp*, _Fn && __test_fn)
		1543	{
		1544	return __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
		1545	}
		1546
		1547	#endif // _LIBCPP_HAS_NO_PLATFORM_WAIT
		1548
		1549	template <class _Atp, class _Tp>
		1550	struct __cxx_atomic_wait_test_fn_impl {
		1551	_Atp* __a;
		1552	_Tp __val;
		1553	memory_order __order;
		1554	_LIBCPP_INLINE_VISIBILITY bool operator()() const
		1555	{
		1556	return !__cxx_nonatomic_compare_equal(__cxx_atomic_load(__a, __order), __val);
		1557	}
		1558	};
		1559
		1560	template <class _Atp, class _Tp>
		1561	_LIBCPP_AVAILABILITY_SYNC
		1562	_LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_wait(_Atp* __a, _Tp const __val, memory_order __order)
		1563	{
		1564	__cxx_atomic_wait_test_fn_impl<_Atp, _Tp> __test_fn = {__a, __val, __order};
		1565	return __cxx_atomic_wait(__a, __test_fn);
		1566	}
		1567
		1568	#endif //_LIBCPP_STD_VER >= 11
		1569
1455	// general atomic<T>	1570	// general atomic<T>
1456		1571
1457	template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>	1572	template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
...	@@ -1532,6 +1647,19 @@ struct __atomic_base // false	...	@@ -1532,6 +1647,19 @@ struct __atomic_base // false
1532	memory_order __m = memory_order_seq_cst) _NOEXCEPT	1647	memory_order __m = memory_order_seq_cst) _NOEXCEPT
1533	{return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}	1648	{return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
1534		1649
		1650	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
		1651	{__cxx_atomic_wait(&__a_, __v, __m);}
		1652	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT
		1653	{__cxx_atomic_wait(&__a_, __v, __m);}
		1654	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() volatile _NOEXCEPT
		1655	{__cxx_atomic_notify_one(&__a_);}
		1656	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() _NOEXCEPT
		1657	{__cxx_atomic_notify_one(&__a_);}
		1658	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() volatile _NOEXCEPT
		1659	{__cxx_atomic_notify_all(&__a_);}
		1660	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() _NOEXCEPT
		1661	{__cxx_atomic_notify_all(&__a_);}
		1662
1535	_LIBCPP_INLINE_VISIBILITY	1663	_LIBCPP_INLINE_VISIBILITY
1536	__atomic_base() _NOEXCEPT _LIBCPP_DEFAULT	1664	__atomic_base() _NOEXCEPT _LIBCPP_DEFAULT
1537		1665
...	@@ -1544,8 +1672,11 @@ struct __atomic_base // false	...	@@ -1544,8 +1672,11 @@ struct __atomic_base // false
1544	__atomic_base& operator=(const __atomic_base&) volatile = delete;	1672	__atomic_base& operator=(const __atomic_base&) volatile = delete;
1545	#else	1673	#else
1546	private:	1674	private:
		1675	_LIBCPP_INLINE_VISIBILITY
1547	__atomic_base(const __atomic_base&);	1676	__atomic_base(const __atomic_base&);
		1677	_LIBCPP_INLINE_VISIBILITY
1548	__atomic_base& operator=(const __atomic_base&);	1678	__atomic_base& operator=(const __atomic_base&);
		1679	_LIBCPP_INLINE_VISIBILITY
1549	__atomic_base& operator=(const __atomic_base&) volatile;	1680	__atomic_base& operator=(const __atomic_base&) volatile;
1550	#endif	1681	#endif
1551	};	1682	};
...	@@ -1643,6 +1774,7 @@ struct atomic	...	@@ -1643,6 +1774,7 @@ struct atomic
1643	: public __atomic_base<_Tp>	1774	: public __atomic_base<_Tp>
1644	{	1775	{
1645	typedef __atomic_base<_Tp> __base;	1776	typedef __atomic_base<_Tp> __base;
		1777	typedef _Tp value_type;
1646	_LIBCPP_INLINE_VISIBILITY	1778	_LIBCPP_INLINE_VISIBILITY
1647	atomic() _NOEXCEPT _LIBCPP_DEFAULT	1779	atomic() _NOEXCEPT _LIBCPP_DEFAULT
1648	_LIBCPP_INLINE_VISIBILITY	1780	_LIBCPP_INLINE_VISIBILITY
...	@@ -1663,6 +1795,7 @@ struct atomic<_Tp*>	...	@@ -1663,6 +1795,7 @@ struct atomic<_Tp*>
1663	: public __atomic_base<_Tp*>	1795	: public __atomic_base<_Tp*>
1664	{	1796	{
1665	typedef __atomic_base<_Tp*> __base;	1797	typedef __atomic_base<_Tp*> __base;
		1798	typedef _Tp* value_type;
1666	_LIBCPP_INLINE_VISIBILITY	1799	_LIBCPP_INLINE_VISIBILITY
1667	atomic() _NOEXCEPT _LIBCPP_DEFAULT	1800	atomic() _NOEXCEPT _LIBCPP_DEFAULT
1668	_LIBCPP_INLINE_VISIBILITY	1801	_LIBCPP_INLINE_VISIBILITY
...	@@ -1947,6 +2080,76 @@ atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e,	...	@@ -1947,6 +2080,76 @@ atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e,
1947	return __o->compare_exchange_strong(*__e, __d, __s, __f);	2080	return __o->compare_exchange_strong(*__e, __d, __s, __f);
1948	}	2081	}
1949		2082
		2083	// atomic_wait
		2084
		2085	template <class _Tp>
		2086	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2087	void atomic_wait(const volatile atomic<_Tp>* __o,
		2088	typename atomic<_Tp>::value_type __v) _NOEXCEPT
		2089	{
		2090	return __o->wait(__v);
		2091	}
		2092
		2093	template <class _Tp>
		2094	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2095	void atomic_wait(const atomic<_Tp>* __o,
		2096	typename atomic<_Tp>::value_type __v) _NOEXCEPT
		2097	{
		2098	return __o->wait(__v);
		2099	}
		2100
		2101	// atomic_wait_explicit
		2102
		2103	template <class _Tp>
		2104	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2105	void atomic_wait_explicit(const volatile atomic<_Tp>* __o,
		2106	typename atomic<_Tp>::value_type __v,
		2107	memory_order __m) _NOEXCEPT
		2108	_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
		2109	{
		2110	return __o->wait(__v, __m);
		2111	}
		2112
		2113	template <class _Tp>
		2114	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2115	void atomic_wait_explicit(const atomic<_Tp>* __o,
		2116	typename atomic<_Tp>::value_type __v,
		2117	memory_order __m) _NOEXCEPT
		2118	_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
		2119	{
		2120	return __o->wait(__v, __m);
		2121	}
		2122
		2123	// atomic_notify_one
		2124
		2125	template <class _Tp>
		2126	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2127	void atomic_notify_one(volatile atomic<_Tp>* __o) _NOEXCEPT
		2128	{
		2129	__o->notify_one();
		2130	}
		2131	template <class _Tp>
		2132	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2133	void atomic_notify_one(atomic<_Tp>* __o) _NOEXCEPT
		2134	{
		2135	__o->notify_one();
		2136	}
		2137
		2138	// atomic_notify_one
		2139
		2140	template <class _Tp>
		2141	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2142	void atomic_notify_all(volatile atomic<_Tp>* __o) _NOEXCEPT
		2143	{
		2144	__o->notify_all();
		2145	}
		2146	template <class _Tp>
		2147	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2148	void atomic_notify_all(atomic<_Tp>* __o) _NOEXCEPT
		2149	{
		2150	__o->notify_all();
		2151	}
		2152
1950	// atomic_fetch_add	2153	// atomic_fetch_add
1951		2154
1952	template <class _Tp>	2155	template <class _Tp>
...	@@ -2279,6 +2482,13 @@ typedef struct atomic_flag	...	@@ -2279,6 +2482,13 @@ typedef struct atomic_flag
2279	{	2482	{
2280	__cxx_atomic_impl<_LIBCPP_ATOMIC_FLAG_TYPE> __a_;	2483	__cxx_atomic_impl<_LIBCPP_ATOMIC_FLAG_TYPE> __a_;
2281		2484
		2485	_LIBCPP_INLINE_VISIBILITY
		2486	bool test(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
		2487	{return _LIBCPP_ATOMIC_FLAG_TYPE(true) == __cxx_atomic_load(&__a_, __m);}
		2488	_LIBCPP_INLINE_VISIBILITY
		2489	bool test(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
		2490	{return _LIBCPP_ATOMIC_FLAG_TYPE(true) == __cxx_atomic_load(&__a_, __m);}
		2491
2282	_LIBCPP_INLINE_VISIBILITY	2492	_LIBCPP_INLINE_VISIBILITY
2283	bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT	2493	bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
2284	{return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);}	2494	{return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);}
...	@@ -2292,6 +2502,25 @@ typedef struct atomic_flag	...	@@ -2292,6 +2502,25 @@ typedef struct atomic_flag
2292	void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT	2502	void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT
2293	{__cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);}	2503	{__cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);}
2294		2504
		2505	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2506	void wait(bool __v, memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
		2507	{__cxx_atomic_wait(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);}
		2508	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2509	void wait(bool __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT
		2510	{__cxx_atomic_wait(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);}
		2511	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2512	void notify_one() volatile _NOEXCEPT
		2513	{__cxx_atomic_notify_one(&__a_);}
		2514	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2515	void notify_one() _NOEXCEPT
		2516	{__cxx_atomic_notify_one(&__a_);}
		2517	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2518	void notify_all() volatile _NOEXCEPT
		2519	{__cxx_atomic_notify_all(&__a_);}
		2520	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
		2521	void notify_all() _NOEXCEPT
		2522	{__cxx_atomic_notify_all(&__a_);}
		2523
2295	_LIBCPP_INLINE_VISIBILITY	2524	_LIBCPP_INLINE_VISIBILITY
2296	atomic_flag() _NOEXCEPT _LIBCPP_DEFAULT	2525	atomic_flag() _NOEXCEPT _LIBCPP_DEFAULT
2297		2526
...	@@ -2304,12 +2533,44 @@ typedef struct atomic_flag	...	@@ -2304,12 +2533,44 @@ typedef struct atomic_flag
2304	atomic_flag& operator=(const atomic_flag&) volatile = delete;	2533	atomic_flag& operator=(const atomic_flag&) volatile = delete;
2305	#else	2534	#else
2306	private:	2535	private:
		2536	_LIBCPP_INLINE_VISIBILITY
2307	atomic_flag(const atomic_flag&);	2537	atomic_flag(const atomic_flag&);
		2538	_LIBCPP_INLINE_VISIBILITY
2308	atomic_flag& operator=(const atomic_flag&);	2539	atomic_flag& operator=(const atomic_flag&);
		2540	_LIBCPP_INLINE_VISIBILITY
2309	atomic_flag& operator=(const atomic_flag&) volatile;	2541	atomic_flag& operator=(const atomic_flag&) volatile;
2310	#endif	2542	#endif
2311	} atomic_flag;	2543	} atomic_flag;
2312		2544
		2545
		2546	inline _LIBCPP_INLINE_VISIBILITY
		2547	bool
		2548	atomic_flag_test(const volatile atomic_flag* __o) _NOEXCEPT
		2549	{
		2550	return __o->test();
		2551	}
		2552
		2553	inline _LIBCPP_INLINE_VISIBILITY
		2554	bool
		2555	atomic_flag_test(const atomic_flag* __o) _NOEXCEPT
		2556	{
		2557	return __o->test();
		2558	}
		2559
		2560	inline _LIBCPP_INLINE_VISIBILITY
		2561	bool
		2562	atomic_flag_test_explicit(const volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
		2563	{
		2564	return __o->test(__m);
		2565	}
		2566
		2567	inline _LIBCPP_INLINE_VISIBILITY
		2568	bool
		2569	atomic_flag_test_explicit(const atomic_flag* __o, memory_order __m) _NOEXCEPT
		2570	{
		2571	return __o->test(__m);
		2572	}
		2573
2313	inline _LIBCPP_INLINE_VISIBILITY	2574	inline _LIBCPP_INLINE_VISIBILITY
2314	bool	2575	bool
2315	atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT	2576	atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT
...	@@ -2366,6 +2627,64 @@ atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT	...	@@ -2366,6 +2627,64 @@ atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT
2366	__o->clear(__m);	2627	__o->clear(__m);
2367	}	2628	}
2368		2629
		2630	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2631	void
		2632	atomic_flag_wait(const volatile atomic_flag* __o, bool __v) _NOEXCEPT
		2633	{
		2634	__o->wait(__v);
		2635	}
		2636
		2637	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2638	void
		2639	atomic_flag_wait(const atomic_flag* __o, bool __v) _NOEXCEPT
		2640	{
		2641	__o->wait(__v);
		2642	}
		2643
		2644	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2645	void
		2646	atomic_flag_wait_explicit(const volatile atomic_flag* __o,
		2647	bool __v, memory_order __m) _NOEXCEPT
		2648	{
		2649	__o->wait(__v, __m);
		2650	}
		2651
		2652	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2653	void
		2654	atomic_flag_wait_explicit(const atomic_flag* __o,
		2655	bool __v, memory_order __m) _NOEXCEPT
		2656	{
		2657	__o->wait(__v, __m);
		2658	}
		2659
		2660	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2661	void
		2662	atomic_flag_notify_one(volatile atomic_flag* __o) _NOEXCEPT
		2663	{
		2664	__o->notify_one();
		2665	}
		2666
		2667	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2668	void
		2669	atomic_flag_notify_one(atomic_flag* __o) _NOEXCEPT
		2670	{
		2671	__o->notify_one();
		2672	}
		2673
		2674	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2675	void
		2676	atomic_flag_notify_all(volatile atomic_flag* __o) _NOEXCEPT
		2677	{
		2678	__o->notify_all();
		2679	}
		2680
		2681	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC
		2682	void
		2683	atomic_flag_notify_all(atomic_flag* __o) _NOEXCEPT
		2684	{
		2685	__o->notify_all();
		2686	}
		2687
2369	// fences	2688	// fences
2370		2689
2371	inline _LIBCPP_INLINE_VISIBILITY	2690	inline _LIBCPP_INLINE_VISIBILITY
...	@@ -2434,6 +2753,33 @@ typedef atomic<ptrdiff_t> atomic_ptrdiff_t;	...	@@ -2434,6 +2753,33 @@ typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
2434	typedef atomic<intmax_t> atomic_intmax_t;	2753	typedef atomic<intmax_t> atomic_intmax_t;
2435	typedef atomic<uintmax_t> atomic_uintmax_t;	2754	typedef atomic<uintmax_t> atomic_uintmax_t;
2436		2755
		2756	// atomic_*_lock_free : prefer the contention type most highly, then the largest lock-free type
		2757
		2758	#ifdef __cpp_lib_atomic_is_always_lock_free
		2759	# define _LIBCPP_CONTENTION_LOCK_FREE __atomic_always_lock_free(sizeof(__cxx_contention_t), 0)
		2760	#else
		2761	# define _LIBCPP_CONTENTION_LOCK_FREE false
		2762	#endif
		2763
		2764	#if ATOMIC_LLONG_LOCK_FREE == 2
		2765	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, long long>::type __libcpp_signed_lock_free;
		2766	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned long long>::type __libcpp_unsigned_lock_free;
		2767	#elif ATOMIC_INT_LOCK_FREE == 2
		2768	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, int>::type __libcpp_signed_lock_free;
		2769	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned int>::type __libcpp_unsigned_lock_free;
		2770	#elif ATOMIC_SHORT_LOCK_FREE == 2
		2771	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, short>::type __libcpp_signed_lock_free;
		2772	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned short>::type __libcpp_unsigned_lock_free;
		2773	#elif ATOMIC_CHAR_LOCK_FREE == 2
		2774	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, char>::type __libcpp_signed_lock_free;
		2775	typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned char>::type __libcpp_unsigned_lock_free;
		2776	#else
		2777	// No signed/unsigned lock-free types
		2778	#endif
		2779
		2780	typedef atomic<__libcpp_signed_lock_free> atomic_signed_lock_free;
		2781	typedef atomic<__libcpp_unsigned_lock_free> atomic_unsigned_lock_free;
		2782
2437	#define ATOMIC_FLAG_INIT {false}	2783	#define ATOMIC_FLAG_INIT {false}
2438	#define ATOMIC_VAR_INIT(__v) {__v}	2784	#define ATOMIC_VAR_INIT(__v) {__v}
2439		2785

lib/libcxx/include/barrier created+322

...	@@ -0,0 +1,322 @@
1	// -- C++ --
2	//===--------------------------- barrier ----------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP_BARRIER
11	#define _LIBCPP_BARRIER
12
13	/*
14	barrier synopsis
15
16	namespace std
17	{
18
19	template<class CompletionFunction = see below>
20	class barrier
21	{
22	public:
23	using arrival_token = see below;
24
25	constexpr explicit barrier(ptrdiff_t phase_count,
26	CompletionFunction f = CompletionFunction());
27	~barrier();
28
29	barrier(const barrier&) = delete;
30	barrier& operator=(const barrier&) = delete;
31
32	[[nodiscard]] arrival_token arrive(ptrdiff_t update = 1);
33	void wait(arrival_token&& arrival) const;
34
35	void arrive_and_wait();
36	void arrive_and_drop();
37
38	private:
39	CompletionFunction completion; // exposition only
40	};
41
42	}
43
44	*/
45
46	#include <__config>
47	#include <atomic>
48	#ifndef _LIBCPP_HAS_NO_TREE_BARRIER
49	# include <memory>
50	#endif
51
52	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
53	#pragma GCC system_header
54	#endif
55
56	#ifdef _LIBCPP_HAS_NO_THREADS
57	# error <barrier> is not supported on this single threaded system
58	#endif
59
60	#if _LIBCPP_STD_VER >= 14
61
62	_LIBCPP_BEGIN_NAMESPACE_STD
63
64	struct __empty_completion
65	{
66	inline _LIBCPP_INLINE_VISIBILITY
67	void operator()() noexcept
68	{
69	}
70	};
71
72	#ifndef _LIBCPP_HAS_NO_TREE_BARRIER
73
74	/*
75
76	The default implementation of __barrier_base is a classic tree barrier.
77
78	It looks different from literature pseudocode for two main reasons:
79	1. Threads that call into std::barrier functions do not provide indices,
80	so a numbering step is added before the actual barrier algorithm,
81	appearing as an N+1 round to the N rounds of the tree barrier.
82	2. A great deal of attention has been paid to avoid cache line thrashing
83	by flattening the tree structure into cache-line sized arrays, that
84	are indexed in an efficient way.
85
86	*/
87
88	using __barrier_phase_t = uint8_t;
89
90	class __barrier_algorithm_base;
91
92	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
93	__barrier_algorithm_base* __construct_barrier_algorithm_base(ptrdiff_t& __expected);
94
95	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
96	bool __arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier,
97	__barrier_phase_t __old_phase);
98
99	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
100	void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier);
101
102	template<class _CompletionF>
103	class __barrier_base {
104
105	ptrdiff_t __expected;
106	unique_ptr<__barrier_algorithm_base,
107	void ()(__barrier_algorithm_base)> __base;
108	__atomic_base<ptrdiff_t> __expected_adjustment;
109	_CompletionF __completion;
110	__atomic_base<__barrier_phase_t> __phase;
111
112	public:
113	using arrival_token = __barrier_phase_t;
114
115	static constexpr ptrdiff_t max() noexcept {
116	return numeric_limits<ptrdiff_t>::max();
117	}
118
119	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
120	__barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
121	: __expected(__expected), __base(__construct_barrier_algorithm_base(this->__expected),
122	&__destroy_barrier_algorithm_base),
123	__expected_adjustment(0), __completion(move(__completion)), __phase(0)
124	{
125	}
126	[[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
127	arrival_token arrive(ptrdiff_t update)
128	{
129	auto const __old_phase = __phase.load(memory_order_relaxed);
130	for(; update; --update)
131	if(__arrive_barrier_algorithm_base(__base.get(), __old_phase)) {
132	__completion();
133	__expected += __expected_adjustment.load(memory_order_relaxed);
134	__expected_adjustment.store(0, memory_order_relaxed);
135	__phase.store(__old_phase + 2, memory_order_release);
136	__phase.notify_all();
137	}
138	return __old_phase;
139	}
140	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
141	void wait(arrival_token&& __old_phase) const
142	{
143	auto const __test_fn = [=]() -> bool {
144	return __phase.load(memory_order_acquire) != __old_phase;
145	};
146	__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
147	}
148	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
149	void arrive_and_drop()
150	{
151	__expected_adjustment.fetch_sub(1, memory_order_relaxed);
152	(void)arrive(1);
153	}
154	};
155
156	#else
157
158	/*
159
160	The alternative implementation of __barrier_base is a central barrier.
161
162	Two versions of this algorithm are provided:
163	1. A fairly straightforward implementation of the litterature for the
164	general case where the completion function is not empty.
165	2. An optimized implementation that exploits 2's complement arithmetic
166	and well-defined overflow in atomic arithmetic, to handle the phase
167	roll-over for free.
168
169	*/
170
171	template<class _CompletionF>
172	class __barrier_base {
173
174	__atomic_base<ptrdiff_t> __expected;
175	__atomic_base<ptrdiff_t> __arrived;
176	_CompletionF __completion;
177	__atomic_base<bool> __phase;
178	public:
179	using arrival_token = bool;
180
181	static constexpr ptrdiff_t max() noexcept {
182	return numeric_limits<ptrdiff_t>::max();
183	}
184
185	_LIBCPP_INLINE_VISIBILITY
186	__barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
187	: __expected(__expected), __arrived(__expected), __completion(move(__completion)), __phase(false)
188	{
189	}
190	[[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
191	arrival_token arrive(ptrdiff_t update)
192	{
193	auto const __old_phase = __phase.load(memory_order_relaxed);
194	auto const __result = __arrived.fetch_sub(update, memory_order_acq_rel) - update;
195	auto const new_expected = __expected.load(memory_order_relaxed);
196	if(0 == __result) {
197	__completion();
198	__arrived.store(new_expected, memory_order_relaxed);
199	__phase.store(!__old_phase, memory_order_release);
200	__phase.notify_all();
201	}
202	return __old_phase;
203	}
204	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
205	void wait(arrival_token&& __old_phase) const
206	{
207	__phase.wait(__old_phase, memory_order_acquire);
208	}
209	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
210	void arrive_and_drop()
211	{
212	__expected.fetch_sub(1, memory_order_relaxed);
213	(void)arrive(1);
214	}
215	};
216
217	template<>
218	class __barrier_base<__empty_completion> {
219
220	static constexpr uint64_t __expected_unit = 1ull;
221	static constexpr uint64_t __arrived_unit = 1ull << 32;
222	static constexpr uint64_t __expected_mask = __arrived_unit - 1;
223	static constexpr uint64_t __phase_bit = 1ull << 63;
224	static constexpr uint64_t __arrived_mask = (__phase_bit - 1) & ~__expected_mask;
225
226	__atomic_base<uint64_t> __phase_arrived_expected;
227
228	static _LIBCPP_INLINE_VISIBILITY
229	constexpr uint64_t __init(ptrdiff_t __count) _NOEXCEPT
230	{
231	return ((uint64_t(1u << 31) - __count) << 32)
232	\| (uint64_t(1u << 31) - __count);
233	}
234
235	public:
236	using arrival_token = uint64_t;
237
238	static constexpr ptrdiff_t max() noexcept {
239	return ptrdiff_t(1u << 31) - 1;
240	}
241
242	_LIBCPP_INLINE_VISIBILITY
243	explicit inline __barrier_base(ptrdiff_t __count, __empty_completion = __empty_completion())
244	: __phase_arrived_expected(__init(__count))
245	{
246	}
247	[[nodiscard]] inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
248	arrival_token arrive(ptrdiff_t update)
249	{
250	auto const __inc = __arrived_unit * update;
251	auto const __old = __phase_arrived_expected.fetch_add(__inc, memory_order_acq_rel);
252	if((__old ^ (__old + __inc)) & __phase_bit) {
253	__phase_arrived_expected.fetch_add((__old & __expected_mask) << 32, memory_order_relaxed);
254	__phase_arrived_expected.notify_all();
255	}
256	return __old & __phase_bit;
257	}
258	inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
259	void wait(arrival_token&& __phase) const
260	{
261	auto const __test_fn = [=]() -> bool {
262	uint64_t const __current = __phase_arrived_expected.load(memory_order_acquire);
263	return ((__current & __phase_bit) != __phase);
264	};
265	__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
266	}
267	inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
268	void arrive_and_drop()
269	{
270	__phase_arrived_expected.fetch_add(__expected_unit, memory_order_relaxed);
271	(void)arrive(1);
272	}
273	};
274
275	#endif //_LIBCPP_HAS_NO_TREE_BARRIER
276
277	template<class _CompletionF = __empty_completion>
278	class barrier {
279
280	__barrier_base<_CompletionF> __b;
281	public:
282	using arrival_token = typename __barrier_base<_CompletionF>::arrival_token;
283
284	static constexpr ptrdiff_t max() noexcept {
285	return __barrier_base<_CompletionF>::max();
286	}
287
288	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
289	barrier(ptrdiff_t __count, _CompletionF __completion = _CompletionF())
290	: __b(__count, std::move(__completion)) {
291	}
292
293	barrier(barrier const&) = delete;
294	barrier& operator=(barrier const&) = delete;
295
296	[[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
297	arrival_token arrive(ptrdiff_t update = 1)
298	{
299	return __b.arrive(update);
300	}
301	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
302	void wait(arrival_token&& __phase) const
303	{
304	__b.wait(std::move(__phase));
305	}
306	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
307	void arrive_and_wait()
308	{
309	wait(arrive());
310	}
311	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
312	void arrive_and_drop()
313	{
314	__b.arrive_and_drop();
315	}
316	};
317
318	_LIBCPP_END_NAMESPACE_STD
319
320	#endif // _LIBCPP_STD_VER >= 14
321
322	#endif //_LIBCPP_BARRIER

lib/libcxx/include/bit+5-4

...	@@ -15,6 +15,7 @@	...	@@ -15,6 +15,7 @@
15		15
16	namespace std {	16	namespace std {
17		17
		18	// [bit.pow.two], integral powers of 2
18	template <class T>	19	template <class T>
19	constexpr bool ispow2(T x) noexcept; // C++20	20	constexpr bool ispow2(T x) noexcept; // C++20
20	template <class T>	21	template <class T>
...	@@ -24,13 +25,13 @@ namespace std {	...	@@ -24,13 +25,13 @@ namespace std {
24	template <class T>	25	template <class T>
25	constexpr T log2p1(T x) noexcept; // C++20	26	constexpr T log2p1(T x) noexcept; // C++20
26		27
27	// 23.20.2, rotating	28	// [bit.rotate], rotating
28	template<class T>	29	template<class T>
29	constexpr T rotl(T x, unsigned int s) noexcept; // C++20	30	constexpr T rotl(T x, unsigned int s) noexcept; // C++20
30	template<class T>	31	template<class T>
31	constexpr T rotr(T x, unsigned int s) noexcept; // C++20	32	constexpr T rotr(T x, unsigned int s) noexcept; // C++20
32		33
33	// 23.20.3, counting	34	// [bit.count], counting
34	template<class T>	35	template<class T>
35	constexpr int countl_zero(T x) noexcept; // C++20	36	constexpr int countl_zero(T x) noexcept; // C++20
36	template<class T>	37	template<class T>
...	@@ -42,7 +43,7 @@ namespace std {	...	@@ -42,7 +43,7 @@ namespace std {
42	template<class T>	43	template<class T>
43	constexpr int popcount(T x) noexcept; // C++20	44	constexpr int popcount(T x) noexcept; // C++20
44		45
45	// 20.15.9, endian	46	// [bit.endian], endian
46	enum class endian {	47	enum class endian {
47	little = see below, // C++20	48	little = see below, // C++20
48	big = see below, // C++20	49	big = see below, // C++20
...	@@ -350,7 +351,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR	...	@@ -350,7 +351,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
350	bool __ispow2(_Tp __t) _NOEXCEPT	351	bool __ispow2(_Tp __t) _NOEXCEPT
351	{	352	{
352	static_assert(__bitop_unsigned_integer<_Tp>::value, "__ispow2 requires unsigned");	353	static_assert(__bitop_unsigned_integer<_Tp>::value, "__ispow2 requires unsigned");
353	return __t != 0 && (((__t & (__t - 1)) == 0));	354	return __t != 0 && (((__t & (__t - 1)) == 0));
354	}	355	}
355		356
356		357

lib/libcxx/include/charconv+11-2

...	@@ -73,6 +73,7 @@ namespace std {	...	@@ -73,6 +73,7 @@ namespace std {
73		73
74	*/	74	*/
75		75
		76	#include <__config>
76	#include <__errc>	77	#include <__errc>
77	#include <type_traits>	78	#include <type_traits>
78	#include <limits>	79	#include <limits>
...	@@ -92,8 +93,8 @@ _LIBCPP_PUSH_MACROS	...	@@ -92,8 +93,8 @@ _LIBCPP_PUSH_MACROS
92	_LIBCPP_BEGIN_NAMESPACE_STD	93	_LIBCPP_BEGIN_NAMESPACE_STD
93		94
94	namespace __itoa {	95	namespace __itoa {
95	_LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer);	96	_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer) _NOEXCEPT;
96	_LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer);	97	_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) _NOEXCEPT;
97	}	98	}
98		99
99	#ifndef _LIBCPP_CXX03_LANG	100	#ifndef _LIBCPP_CXX03_LANG
...	@@ -167,6 +168,7 @@ struct _LIBCPP_HIDDEN __traits_base	...	@@ -167,6 +168,7 @@ struct _LIBCPP_HIDDEN __traits_base
167	}	168	}
168	#endif	169	#endif
169		170
		171	_LIBCPP_AVAILABILITY_TO_CHARS
170	static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p)	172	static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p)
171	{	173	{
172	return __u64toa(__v, __p);	174	return __u64toa(__v, __p);
...	@@ -189,6 +191,7 @@ struct _LIBCPP_HIDDEN	...	@@ -189,6 +191,7 @@ struct _LIBCPP_HIDDEN
189	}	191	}
190	#endif	192	#endif
191		193
		194	_LIBCPP_AVAILABILITY_TO_CHARS
192	static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p)	195	static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p)
193	{	196	{
194	return __u32toa(__v, __p);	197	return __u32toa(__v, __p);
...	@@ -292,6 +295,7 @@ __to_unsigned(_Tp __x)	...	@@ -292,6 +295,7 @@ __to_unsigned(_Tp __x)
292	}	295	}
293		296
294	template <typename _Tp>	297	template <typename _Tp>
		298	_LIBCPP_AVAILABILITY_TO_CHARS
295	inline _LIBCPP_INLINE_VISIBILITY to_chars_result	299	inline _LIBCPP_INLINE_VISIBILITY to_chars_result
296	__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)	300	__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
297	{	301	{
...	@@ -306,6 +310,7 @@ __to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)	...	@@ -306,6 +310,7 @@ __to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
306	}	310	}
307		311
308	template <typename _Tp>	312	template <typename _Tp>
		313	_LIBCPP_AVAILABILITY_TO_CHARS
309	inline _LIBCPP_INLINE_VISIBILITY to_chars_result	314	inline _LIBCPP_INLINE_VISIBILITY to_chars_result
310	__to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)	315	__to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
311	{	316	{
...	@@ -337,6 +342,7 @@ __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)	...	@@ -337,6 +342,7 @@ __to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
337	}	342	}
338		343
339	template <typename _Tp>	344	template <typename _Tp>
		345	_LIBCPP_AVAILABILITY_TO_CHARS
340	inline _LIBCPP_INLINE_VISIBILITY to_chars_result	346	inline _LIBCPP_INLINE_VISIBILITY to_chars_result
341	__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,	347	__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
342	true_type)	348	true_type)
...	@@ -352,6 +358,7 @@ __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,	...	@@ -352,6 +358,7 @@ __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
352	}	358	}
353		359
354	template <typename _Tp>	360	template <typename _Tp>
		361	_LIBCPP_AVAILABILITY_TO_CHARS
355	inline _LIBCPP_INLINE_VISIBILITY to_chars_result	362	inline _LIBCPP_INLINE_VISIBILITY to_chars_result
356	__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,	363	__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
357	false_type)	364	false_type)
...	@@ -380,6 +387,7 @@ __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,	...	@@ -380,6 +387,7 @@ __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
380	}	387	}
381		388
382	template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>	389	template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
		390	_LIBCPP_AVAILABILITY_TO_CHARS
383	inline _LIBCPP_INLINE_VISIBILITY to_chars_result	391	inline _LIBCPP_INLINE_VISIBILITY to_chars_result
384	to_chars(char* __first, char* __last, _Tp __value)	392	to_chars(char* __first, char* __last, _Tp __value)
385	{	393	{
...	@@ -387,6 +395,7 @@ to_chars(char* __first, char* __last, _Tp __value)	...	@@ -387,6 +395,7 @@ to_chars(char* __first, char* __last, _Tp __value)
387	}	395	}
388		396
389	template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>	397	template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
		398	_LIBCPP_AVAILABILITY_TO_CHARS
390	inline _LIBCPP_INLINE_VISIBILITY to_chars_result	399	inline _LIBCPP_INLINE_VISIBILITY to_chars_result
391	to_chars(char* __first, char* __last, _Tp __value, int __base)	400	to_chars(char* __first, char* __last, _Tp __value, int __base)
392	{	401	{

lib/libcxx/include/chrono+1-1

...	@@ -2454,7 +2454,7 @@ chrono::day year_month_day_last::day() const noexcept	...	@@ -2454,7 +2454,7 @@ chrono::day year_month_day_last::day() const noexcept
2454	chrono::day(31), chrono::day(31), chrono::day(30),	2454	chrono::day(31), chrono::day(31), chrono::day(30),
2455	chrono::day(31), chrono::day(30), chrono::day(31)	2455	chrono::day(31), chrono::day(30), chrono::day(31)
2456	};	2456	};
2457	return month() != February \|\| !__y.is_leap() ?	2457	return (month() != February \|\| !__y.is_leap()) && month().ok() ?
2458	__d[static_cast<unsigned>(month()) - 1] : chrono::day{29};	2458	__d[static_cast<unsigned>(month()) - 1] : chrono::day{29};
2459	}	2459	}
2460		2460

lib/libcxx/include/cmath+4

 @@ -296,6 +296,10 @@ floating_point trunc (arithmetic x);
 float          truncf(float x);
 long double    truncl(long double x);
+constexpr float       lerp(float a, float b, float t) noexcept;                   // C++20
+constexpr double      lerp(double a, double b, double t) noexcept;                // C++20
+constexpr long double lerp(long double a, long double b, long double t) noexcept; // C++20
 }  // std
 */

lib/libcxx/include/codecvt+36-36

...	@@ -102,11 +102,11 @@ protected:	...	@@ -102,11 +102,11 @@ protected:
102	virtual result	102	virtual result
103	do_unshift(state_type& __st,	103	do_unshift(state_type& __st,
104	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	104	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
105	virtual int do_encoding() const throw();	105	virtual int do_encoding() const _NOEXCEPT;
106	virtual bool do_always_noconv() const throw();	106	virtual bool do_always_noconv() const _NOEXCEPT;
107	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	107	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
108	size_t __mx) const;	108	size_t __mx) const;
109	virtual int do_max_length() const throw();	109	virtual int do_max_length() const _NOEXCEPT;
110	};	110	};
111		111
112	template <>	112	template <>
...	@@ -137,11 +137,11 @@ protected:	...	@@ -137,11 +137,11 @@ protected:
137	virtual result	137	virtual result
138	do_unshift(state_type& __st,	138	do_unshift(state_type& __st,
139	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	139	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
140	virtual int do_encoding() const throw();	140	virtual int do_encoding() const _NOEXCEPT;
141	virtual bool do_always_noconv() const throw();	141	virtual bool do_always_noconv() const _NOEXCEPT;
142	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	142	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
143	size_t __mx) const;	143	size_t __mx) const;
144	virtual int do_max_length() const throw();	144	virtual int do_max_length() const _NOEXCEPT;
145	};	145	};
146		146
147	template <>	147	template <>
...	@@ -172,11 +172,11 @@ protected:	...	@@ -172,11 +172,11 @@ protected:
172	virtual result	172	virtual result
173	do_unshift(state_type& __st,	173	do_unshift(state_type& __st,
174	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	174	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
175	virtual int do_encoding() const throw();	175	virtual int do_encoding() const _NOEXCEPT;
176	virtual bool do_always_noconv() const throw();	176	virtual bool do_always_noconv() const _NOEXCEPT;
177	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	177	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
178	size_t __mx) const;	178	size_t __mx) const;
179	virtual int do_max_length() const throw();	179	virtual int do_max_length() const _NOEXCEPT;
180	};	180	};
181		181
182	template <class _Elem, unsigned long _Maxcode = 0x10ffff,	182	template <class _Elem, unsigned long _Maxcode = 0x10ffff,
...	@@ -225,11 +225,11 @@ protected:	...	@@ -225,11 +225,11 @@ protected:
225	virtual result	225	virtual result
226	do_unshift(state_type& __st,	226	do_unshift(state_type& __st,
227	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	227	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
228	virtual int do_encoding() const throw();	228	virtual int do_encoding() const _NOEXCEPT;
229	virtual bool do_always_noconv() const throw();	229	virtual bool do_always_noconv() const _NOEXCEPT;
230	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	230	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
231	size_t __mx) const;	231	size_t __mx) const;
232	virtual int do_max_length() const throw();	232	virtual int do_max_length() const _NOEXCEPT;
233	};	233	};
234		234
235	template <>	235	template <>
...	@@ -260,11 +260,11 @@ protected:	...	@@ -260,11 +260,11 @@ protected:
260	virtual result	260	virtual result
261	do_unshift(state_type& __st,	261	do_unshift(state_type& __st,
262	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	262	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
263	virtual int do_encoding() const throw();	263	virtual int do_encoding() const _NOEXCEPT;
264	virtual bool do_always_noconv() const throw();	264	virtual bool do_always_noconv() const _NOEXCEPT;
265	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	265	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
266	size_t __mx) const;	266	size_t __mx) const;
267	virtual int do_max_length() const throw();	267	virtual int do_max_length() const _NOEXCEPT;
268	};	268	};
269		269
270	template <>	270	template <>
...	@@ -295,11 +295,11 @@ protected:	...	@@ -295,11 +295,11 @@ protected:
295	virtual result	295	virtual result
296	do_unshift(state_type& __st,	296	do_unshift(state_type& __st,
297	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	297	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
298	virtual int do_encoding() const throw();	298	virtual int do_encoding() const _NOEXCEPT;
299	virtual bool do_always_noconv() const throw();	299	virtual bool do_always_noconv() const _NOEXCEPT;
300	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	300	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
301	size_t __mx) const;	301	size_t __mx) const;
302	virtual int do_max_length() const throw();	302	virtual int do_max_length() const _NOEXCEPT;
303	};	303	};
304		304
305	template <>	305	template <>
...	@@ -330,11 +330,11 @@ protected:	...	@@ -330,11 +330,11 @@ protected:
330	virtual result	330	virtual result
331	do_unshift(state_type& __st,	331	do_unshift(state_type& __st,
332	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	332	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
333	virtual int do_encoding() const throw();	333	virtual int do_encoding() const _NOEXCEPT;
334	virtual bool do_always_noconv() const throw();	334	virtual bool do_always_noconv() const _NOEXCEPT;
335	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	335	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
336	size_t __mx) const;	336	size_t __mx) const;
337	virtual int do_max_length() const throw();	337	virtual int do_max_length() const _NOEXCEPT;
338	};	338	};
339		339
340	template <>	340	template <>
...	@@ -365,11 +365,11 @@ protected:	...	@@ -365,11 +365,11 @@ protected:
365	virtual result	365	virtual result
366	do_unshift(state_type& __st,	366	do_unshift(state_type& __st,
367	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	367	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
368	virtual int do_encoding() const throw();	368	virtual int do_encoding() const _NOEXCEPT;
369	virtual bool do_always_noconv() const throw();	369	virtual bool do_always_noconv() const _NOEXCEPT;
370	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	370	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
371	size_t __mx) const;	371	size_t __mx) const;
372	virtual int do_max_length() const throw();	372	virtual int do_max_length() const _NOEXCEPT;
373	};	373	};
374		374
375	template <>	375	template <>
...	@@ -400,11 +400,11 @@ protected:	...	@@ -400,11 +400,11 @@ protected:
400	virtual result	400	virtual result
401	do_unshift(state_type& __st,	401	do_unshift(state_type& __st,
402	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	402	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
403	virtual int do_encoding() const throw();	403	virtual int do_encoding() const _NOEXCEPT;
404	virtual bool do_always_noconv() const throw();	404	virtual bool do_always_noconv() const _NOEXCEPT;
405	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	405	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
406	size_t __mx) const;	406	size_t __mx) const;
407	virtual int do_max_length() const throw();	407	virtual int do_max_length() const _NOEXCEPT;
408	};	408	};
409		409
410	template <class _Elem, unsigned long _Maxcode = 0x10ffff,	410	template <class _Elem, unsigned long _Maxcode = 0x10ffff,
...	@@ -453,11 +453,11 @@ protected:	...	@@ -453,11 +453,11 @@ protected:
453	virtual result	453	virtual result
454	do_unshift(state_type& __st,	454	do_unshift(state_type& __st,
455	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	455	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
456	virtual int do_encoding() const throw();	456	virtual int do_encoding() const _NOEXCEPT;
457	virtual bool do_always_noconv() const throw();	457	virtual bool do_always_noconv() const _NOEXCEPT;
458	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	458	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
459	size_t __mx) const;	459	size_t __mx) const;
460	virtual int do_max_length() const throw();	460	virtual int do_max_length() const _NOEXCEPT;
461	};	461	};
462		462
463	template <>	463	template <>
...	@@ -488,11 +488,11 @@ protected:	...	@@ -488,11 +488,11 @@ protected:
488	virtual result	488	virtual result
489	do_unshift(state_type& __st,	489	do_unshift(state_type& __st,
490	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	490	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
491	virtual int do_encoding() const throw();	491	virtual int do_encoding() const _NOEXCEPT;
492	virtual bool do_always_noconv() const throw();	492	virtual bool do_always_noconv() const _NOEXCEPT;
493	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	493	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
494	size_t __mx) const;	494	size_t __mx) const;
495	virtual int do_max_length() const throw();	495	virtual int do_max_length() const _NOEXCEPT;
496	};	496	};
497		497
498	template <>	498	template <>
...	@@ -523,11 +523,11 @@ protected:	...	@@ -523,11 +523,11 @@ protected:
523	virtual result	523	virtual result
524	do_unshift(state_type& __st,	524	do_unshift(state_type& __st,
525	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;	525	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
526	virtual int do_encoding() const throw();	526	virtual int do_encoding() const _NOEXCEPT;
527	virtual bool do_always_noconv() const throw();	527	virtual bool do_always_noconv() const _NOEXCEPT;
528	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,	528	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
529	size_t __mx) const;	529	size_t __mx) const;
530	virtual int do_max_length() const throw();	530	virtual int do_max_length() const _NOEXCEPT;
531	};	531	};
532		532
533	template <class _Elem, unsigned long _Maxcode = 0x10ffff,	533	template <class _Elem, unsigned long _Maxcode = 0x10ffff,

lib/libcxx/include/compare+84

...	@@ -43,6 +43,84 @@ namespace std {	...	@@ -43,6 +43,84 @@ namespace std {
43	template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);	43	template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
44	template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);	44	template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);
45	template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);	45	template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);
		46
		47	// [cmp.partialord], Class partial_ordering
		48	class partial_ordering {
		49	public:
		50	// valid values
		51	static const partial_ordering less;
		52	static const partial_ordering equivalent;
		53	static const partial_ordering greater;
		54	static const partial_ordering unordered;
		55
		56	// comparisons
		57	friend constexpr bool operator==(partial_ordering v, unspecified) noexcept;
		58	friend constexpr bool operator==(partial_ordering v, partial_ordering w) noexcept = default;
		59	friend constexpr bool operator< (partial_ordering v, unspecified) noexcept;
		60	friend constexpr bool operator> (partial_ordering v, unspecified) noexcept;
		61	friend constexpr bool operator<=(partial_ordering v, unspecified) noexcept;
		62	friend constexpr bool operator>=(partial_ordering v, unspecified) noexcept;
		63	friend constexpr bool operator< (unspecified, partial_ordering v) noexcept;
		64	friend constexpr bool operator> (unspecified, partial_ordering v) noexcept;
		65	friend constexpr bool operator<=(unspecified, partial_ordering v) noexcept;
		66	friend constexpr bool operator>=(unspecified, partial_ordering v) noexcept;
		67	friend constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept;
		68	friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
		69	};
		70
		71	// [cmp.weakord], Class weak_ordering
		72	class weak_ordering {
		73	public:
		74	// valid values
		75	static const weak_ordering less;
		76	static const weak_ordering equivalent;
		77	static const weak_ordering greater;
		78
		79	// conversions
		80	constexpr operator partial_ordering() const noexcept;
		81
		82	// comparisons
		83	friend constexpr bool operator==(weak_ordering v, unspecified) noexcept;
		84	friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
		85	friend constexpr bool operator< (weak_ordering v, unspecified) noexcept;
		86	friend constexpr bool operator> (weak_ordering v, unspecified) noexcept;
		87	friend constexpr bool operator<=(weak_ordering v, unspecified) noexcept;
		88	friend constexpr bool operator>=(weak_ordering v, unspecified) noexcept;
		89	friend constexpr bool operator< (unspecified, weak_ordering v) noexcept;
		90	friend constexpr bool operator> (unspecified, weak_ordering v) noexcept;
		91	friend constexpr bool operator<=(unspecified, weak_ordering v) noexcept;
		92	friend constexpr bool operator>=(unspecified, weak_ordering v) noexcept;
		93	friend constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept;
		94	friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
		95	};
		96
		97	// [cmp.strongord], Class strong_ordering
		98	class strong_ordering {
		99	public:
		100	// valid values
		101	static const strong_ordering less;
		102	static const strong_ordering equal;
		103	static const strong_ordering equivalent;
		104	static const strong_ordering greater;
		105
		106	// conversions
		107	constexpr operator partial_ordering() const noexcept;
		108	constexpr operator weak_ordering() const noexcept;
		109
		110	// comparisons
		111	friend constexpr bool operator==(strong_ordering v, unspecified) noexcept;
		112	friend constexpr bool operator==(strong_ordering v, strong_ordering w) noexcept = default;
		113	friend constexpr bool operator< (strong_ordering v, unspecified) noexcept;
		114	friend constexpr bool operator> (strong_ordering v, unspecified) noexcept;
		115	friend constexpr bool operator<=(strong_ordering v, unspecified) noexcept;
		116	friend constexpr bool operator>=(strong_ordering v, unspecified) noexcept;
		117	friend constexpr bool operator< (unspecified, strong_ordering v) noexcept;
		118	friend constexpr bool operator> (unspecified, strong_ordering v) noexcept;
		119	friend constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
		120	friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
		121	friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
		122	friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
		123	};
46	}	124	}
47	*/	125	*/
48		126
...	@@ -248,6 +326,8 @@ public:	...	@@ -248,6 +326,8 @@ public:
248	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;	326	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
249		327
250	#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR	328	#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
		329	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default;
		330
251	_LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept;	331	_LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
252	_LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept;	332	_LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
253	#endif	333	#endif
...	@@ -364,6 +444,8 @@ public:	...	@@ -364,6 +444,8 @@ public:
364	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;	444	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
365		445
366	#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR	446	#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
		447	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default;
		448
367	_LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept;	449	_LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
368	_LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept;	450	_LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
369	#endif	451	#endif
...	@@ -490,6 +572,8 @@ public:	...	@@ -490,6 +572,8 @@ public:
490	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;	572	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
491		573
492	#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR	574	#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
		575	_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default;
		576
493	_LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept;	577	_LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
494	_LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept;	578	_LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
495	#endif	579	#endif

lib/libcxx/include/complex+7-6

 @@ -243,6 +243,7 @@ template<class T, class charT, class traits>
 #include <type_traits>
 #include <stdexcept>
 #include <cmath>
+#include <iosfwd>
 #include <sstream>
 #include <version>
 @@ -1406,10 +1407,10 @@ operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
                             __x = complex<_Tp>(__r, __i);
                         }
                         else
-                            __is.setstate(ios_base::failbit);
+                            __is.setstate(__is.failbit);
                     }
                     else
-                        __is.setstate(ios_base::failbit);
+                        __is.setstate(__is.failbit);
                 }
                 else if (__c == _CharT(')'))
                 {
 @@ -1417,10 +1418,10 @@ operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
                     __x = complex<_Tp>(__r, _Tp(0));
                 }
                 else
-                    __is.setstate(ios_base::failbit);
+                    __is.setstate(__is.failbit);
             }
             else
-                __is.setstate(ios_base::failbit);
+                __is.setstate(__is.failbit);
         }
         else
         {
 @@ -1429,11 +1430,11 @@ operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
             if (!__is.fail())
                 __x = complex<_Tp>(__r, _Tp(0));
             else
-                __is.setstate(ios_base::failbit);
+                __is.setstate(__is.failbit);
         }
     }
     else
-        __is.setstate(ios_base::failbit);
+        __is.setstate(__is.failbit);
     return __is;
 }

lib/libcxx/include/concepts created+166

...	@@ -0,0 +1,166 @@
1	// -- C++ --
2	//===-------------------------- concepts ----------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP_CONCEPTS
11	#define _LIBCPP_CONCEPTS
12
13	/*
14	concepts synopsis
15	namespace std {
16	// [concepts.lang], language-related concepts
17	// [concept.same], concept same_as
18	template<class T, class U>
19	concept same_as = see below;
20
21	// [concept.derived], concept derived_from
22	template<class Derived, class Base>
23	concept derived_from = see below;
24
25	// [concept.convertible], concept convertible_to
26	template<class From, class To>
27	concept convertible_to = see below;
28
29	// [concept.commonref], concept common_reference_with
30	template<class T, class U>
31	concept common_reference_with = see below;
32
33	// [concept.common], concept common_with
34	template<class T, class U>
35	concept common_with = see below;
36
37	// [concepts.arithmetic], arithmetic concepts
38	template<class T>
39	concept integral = see below;
40	template<class T>
41	concept signed_integral = see below;
42	template<class T>
43	concept unsigned_integral = see below;
44	template<class T>
45	concept floating_point = see below;
46
47	// [concept.assignable], concept assignable_from
48	template<class LHS, class RHS>
49	concept assignable_from = see below;
50
51	// [concept.swappable], concept swappable
52	namespace ranges {
53	inline namespace unspecified {
54	inline constexpr unspecified swap = unspecified;
55	}
56	}
57	template<class T>
58	concept swappable = see below;
59	template<class T, class U>
60	concept swappable_with = see below;
61
62	// [concept.destructible], concept destructible
63	template<class T>
64	concept destructible = see below;
65
66	// [concept.constructible], concept constructible_from
67	template<class T, class... Args>
68	concept constructible_from = see below;
69
70	// [concept.defaultconstructible], concept default_constructible
71	template<class T>
72	concept default_constructible = see below;
73
74	// [concept.moveconstructible], concept move_constructible
75	template<class T>
76	concept move_constructible = see below;
77
78	// [concept.copyconstructible], concept copy_constructible
79	template<class T>
80	concept copy_constructible = see below;
81
82	// [concepts.compare], comparison concepts
83	// [concept.boolean], concept boolean
84	template<class B>
85	concept boolean = see below;
86
87	// [concept.equalitycomparable], concept equality_comparable
88	template<class T>
89	concept equality_comparable = see below;
90	template<class T, class U>
91	concept equality_comparable_with = see below;
92
93	// [concept.totallyordered], concept totally_ordered
94	template<class T>
95	concept totally_ordered = see below;
96	template<class T, class U>
97	concept totally_ordered_with = see below;
98
99	// [concepts.object], object concepts
100	template<class T>
101	concept movable = see below;
102	template<class T>
103	concept copyable = see below;
104	template<class T>
105	concept semiregular = see below;
106	template<class T>
107	concept regular = see below;
108
109	// [concepts.callable], callable concepts
110	// [concept.invocable], concept invocable
111	template<class F, class... Args>
112	concept invocable = see below;
113
114	// [concept.regularinvocable], concept regular_invocable
115	template<class F, class... Args>
116	concept regular_invocable = see below;
117
118	// [concept.predicate], concept predicate
119	template<class F, class... Args>
120	concept predicate = see below;
121
122	// [concept.relation], concept relation
123	template<class R, class T, class U>
124	concept relation = see below;
125
126	// [concept.equiv], concept equivalence_relation
127	template<class R, class T, class U>
128	concept equivalence_relation = see below;
129
130	// [concept.strictweakorder], concept strict_weak_order
131	template<class R, class T, class U>
132	concept strict_weak_order = see below;
133	}
134
135	*/
136
137	#include <__config>
138	#include <type_traits>
139	#include <version>
140
141	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
142	#pragma GCC system_header
143	#endif
144
145	_LIBCPP_PUSH_MACROS
146	#include <__undef_macros>
147
148	_LIBCPP_BEGIN_NAMESPACE_STD
149
150	#if _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
151
152	// [concept.same]
153
154	template<class _Tp, class _Up>
155	concept __same_as_impl = _VSTD::_IsSame<_Tp, _Up>::value;
156
157	template<class _Tp, class _Up>
158	concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
159
160	#endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
161
162	_LIBCPP_END_NAMESPACE_STD
163
164	_LIBCPP_POP_MACROS
165
166	#endif // _LIBCPP_CONCEPTS

lib/libcxx/include/cstddef+56-8

...	@@ -25,7 +25,7 @@ Types:	...	@@ -25,7 +25,7 @@ Types:
25		25
26	ptrdiff_t	26	ptrdiff_t
27	size_t	27	size_t
28	max_align_t	28	max_align_t // C++11
29	nullptr_t	29	nullptr_t
30	byte // C++17	30	byte // C++17
31		31
...	@@ -49,12 +49,34 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -49,12 +49,34 @@ _LIBCPP_BEGIN_NAMESPACE_STD
49	using ::ptrdiff_t;	49	using ::ptrdiff_t;
50	using ::size_t;	50	using ::size_t;
51		51
52	#if defined(__CLANG_MAX_ALIGN_T_DEFINED) \|\| defined(_GCC_MAX_ALIGN_T) \|\| \	52	#if !defined(_LIBCPP_CXX03_LANG)
53	defined(__DEFINED_max_align_t) \|\| defined(__NetBSD__)
54	// Re-use the compiler's <stddef.h> max_align_t where possible.
55	using ::max_align_t;	53	using ::max_align_t;
56	#else	54	#endif
57	typedef long double max_align_t;	55
		56	template <class _Tp> struct __libcpp_is_integral { enum { value = 0 }; };
		57	template <> struct __libcpp_is_integral<bool> { enum { value = 1 }; };
		58	template <> struct __libcpp_is_integral<char> { enum { value = 1 }; };
		59	template <> struct __libcpp_is_integral<signed char> { enum { value = 1 }; };
		60	template <> struct __libcpp_is_integral<unsigned char> { enum { value = 1 }; };
		61	template <> struct __libcpp_is_integral<wchar_t> { enum { value = 1 }; };
		62	#ifndef _LIBCPP_NO_HAS_CHAR8_T
		63	template <> struct __libcpp_is_integral<char8_t> { enum { value = 1 }; };
		64	#endif
		65	#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
		66	template <> struct __libcpp_is_integral<char16_t> { enum { value = 1 }; };
		67	template <> struct __libcpp_is_integral<char32_t> { enum { value = 1 }; };
		68	#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
		69	template <> struct __libcpp_is_integral<short> { enum { value = 1 }; };
		70	template <> struct __libcpp_is_integral<unsigned short> { enum { value = 1 }; };
		71	template <> struct __libcpp_is_integral<int> { enum { value = 1 }; };
		72	template <> struct __libcpp_is_integral<unsigned int> { enum { value = 1 }; };
		73	template <> struct __libcpp_is_integral<long> { enum { value = 1 }; };
		74	template <> struct __libcpp_is_integral<unsigned long> { enum { value = 1 }; };
		75	template <> struct __libcpp_is_integral<long long> { enum { value = 1 }; };
		76	template <> struct __libcpp_is_integral<unsigned long long> { enum { value = 1 }; };
		77	#ifndef _LIBCPP_HAS_NO_INT128
		78	template <> struct __libcpp_is_integral<__int128_t> { enum { value = 1 }; };
		79	template <> struct __libcpp_is_integral<__uint128_t> { enum { value = 1 }; };
58	#endif	80	#endif
59		81
60	_LIBCPP_END_NAMESPACE_STD	82	_LIBCPP_END_NAMESPACE_STD
...	@@ -64,6 +86,11 @@ namespace std // purposefully not versioned	...	@@ -64,6 +86,11 @@ namespace std // purposefully not versioned
64	{	86	{
65	enum class byte : unsigned char {};	87	enum class byte : unsigned char {};
66		88
		89
		90	template <bool> struct __enable_if_integral_imp {};
		91	template <> struct __enable_if_integral_imp<true> { using type = byte; };
		92	template <class _Tp> using _EnableByteOverload = typename __enable_if_integral_imp<__libcpp_is_integral<_Tp>::value>::type;
		93
67	constexpr byte operator\| (byte __lhs, byte __rhs) noexcept	94	constexpr byte operator\| (byte __lhs, byte __rhs) noexcept
68	{	95	{
69	return static_cast<byte>(	96	return static_cast<byte>(
...	@@ -104,10 +131,31 @@ constexpr byte operator~ (byte __b) noexcept	...	@@ -104,10 +131,31 @@ constexpr byte operator~ (byte __b) noexcept
104	~static_cast<unsigned int>(__b)	131	~static_cast<unsigned int>(__b)
105	));	132	));
106	}	133	}
107		134	template <class _Integer>
		135	constexpr _EnableByteOverload<_Integer> &
		136	operator<<=(byte& __lhs, _Integer __shift) noexcept
		137	{ return __lhs = __lhs << __shift; }
		138
		139	template <class _Integer>
		140	constexpr _EnableByteOverload<_Integer>
		141	operator<< (byte __lhs, _Integer __shift) noexcept
		142	{ return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) << __shift)); }
		143
		144	template <class _Integer>
		145	constexpr _EnableByteOverload<_Integer> &
		146	operator>>=(byte& __lhs, _Integer __shift) noexcept
		147	{ return __lhs = __lhs >> __shift; }
		148
		149	template <class _Integer>
		150	constexpr _EnableByteOverload<_Integer>
		151	operator>> (byte __lhs, _Integer __shift) noexcept
		152	{ return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) >> __shift)); }
		153
		154	template <class _Integer, class = _EnableByteOverload<_Integer> >
		155	constexpr _Integer
		156	to_integer(byte __b) noexcept { return static_cast<_Integer>(__b); }
108	}	157	}
109		158
110	#include <type_traits> // rest of byte
111	#endif	159	#endif
112		160
113	#endif // _LIBCPP_CSTDDEF	161	#endif // _LIBCPP_CSTDDEF

lib/libcxx/include/cstdio+4

 @@ -131,9 +131,13 @@ using ::putc;
 using ::ungetc;
 using ::fread;
 using ::fwrite;
+#ifndef _LIBCPP_HAS_NO_FGETPOS_FSETPOS
 using ::fgetpos;
+#endif
 using ::fseek;
+#ifndef _LIBCPP_HAS_NO_FGETPOS_FSETPOS
 using ::fsetpos;
+#endif
 using ::ftell;
 using ::rewind;
 using ::clearerr;

lib/libcxx/include/deque+16-8

 @@ -150,9 +150,11 @@ template <class T, class Allocator>
          noexcept(noexcept(x.swap(y)));
 template <class T, class Allocator, class U>
-    void erase(deque<T, Allocator>& c, const U& value);       // C++20
+    typename deque<T, Allocator>::size_type
+    erase(deque<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
+    typename deque<T, Allocator>::size_type
+    erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
 }  // std
 @@ -3021,14 +3023,20 @@ swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type
-void erase(deque<_Tp, _Allocator>& __c, const _Up& __v)
+erase(deque<_Tp, _Allocator>& __c, const _Up& __v) {
-{ __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end()); }
+  auto __old_size = __c.size();
+  __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end());
+  return __old_size - __c.size();
+}
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type
-void erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred)
+erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) {
-{ __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
+  auto __old_size = __c.size();
+  __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
+  return __old_size - __c.size();
+}
 #endif

lib/libcxx/include/exception+2

...	@@ -98,6 +98,8 @@ class _LIBCPP_EXCEPTION_ABI exception	...	@@ -98,6 +98,8 @@ class _LIBCPP_EXCEPTION_ABI exception
98	{	98	{
99	public:	99	public:
100	_LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}	100	_LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
		101	_LIBCPP_INLINE_VISIBILITY exception(const exception&) _NOEXCEPT = default;
		102
101	virtual ~exception() _NOEXCEPT;	103	virtual ~exception() _NOEXCEPT;
102	virtual const char* what() const _NOEXCEPT;	104	virtual const char* what() const _NOEXCEPT;
103	};	105	};

lib/libcxx/include/filesystem+1

...	@@ -1346,6 +1346,7 @@ public:	...	@@ -1346,6 +1346,7 @@ public:
1346	_LIBCPP_INLINE_VISIBILITY	1346	_LIBCPP_INLINE_VISIBILITY
1347	const path& path2() const noexcept { return __storage_->__p2_; }	1347	const path& path2() const noexcept { return __storage_->__p2_; }
1348		1348
		1349	filesystem_error(const filesystem_error&) = default;
1349	~filesystem_error() override; // key function	1350	~filesystem_error() override; // key function
1350		1351
1351	_LIBCPP_INLINE_VISIBILITY	1352	_LIBCPP_INLINE_VISIBILITY

lib/libcxx/include/forward_list+12-6

 @@ -169,9 +169,11 @@ template <class T, class Allocator>
          noexcept(noexcept(x.swap(y)));
 template <class T, class Allocator, class U>
-    void erase(forward_list<T, Allocator>& c, const U& value);       // C++20
+    typename forward_list<T, Allocator>::size_type
+    erase(forward_list<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
+    typename forward_list<T, Allocator>::size_type
+    erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
 }  // std
 @@ -1765,13 +1767,17 @@ swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred)
+    typename forward_list<_Tp, _Allocator>::size_type
-{ __c.remove_if(__pred); }
+    erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred) {
+  return __c.remove_if(__pred);
+}
 template <class _Tp, class _Allocator, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v)
+    typename forward_list<_Tp, _Allocator>::size_type
-{ _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
+    erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) {
+  return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
+}
 #endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/functional+112-25

...	@@ -508,6 +508,10 @@ POLICY: For non-variadic implementations, the number of arguments is limited	...	@@ -508,6 +508,10 @@ POLICY: For non-variadic implementations, the number of arguments is limited
508		508
509	#include <__functional_base>	509	#include <__functional_base>
510		510
		511	#if defined(_LIBCPP_HAS_BLOCKS_RUNTIME) && !defined(_LIBCPP_HAS_OBJC_ARC)
		512	#include <Block.h>
		513	#endif
		514
511	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	515	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
512	#pragma GCC system_header	516	#pragma GCC system_header
513	#endif	517	#endif
...	@@ -1434,7 +1438,14 @@ void __throw_bad_function_call()	...	@@ -1434,7 +1438,14 @@ void __throw_bad_function_call()
1434	#endif	1438	#endif
1435	}	1439	}
1436		1440
1437	template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined	1441	#if defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && __has_attribute(deprecated)
		1442	# define _LIBCPP_DEPRECATED_CXX03_FUNCTION \
		1443	__attribute__((deprecated("Using std::function in C++03 is not supported anymore. Please upgrade to C++11 or later, or use a different type")))
		1444	#else
		1445	# define _LIBCPP_DEPRECATED_CXX03_FUNCTION /* nothing */
		1446	#endif
		1447
		1448	template<class _Fp> class _LIBCPP_DEPRECATED_CXX03_FUNCTION _LIBCPP_TEMPLATE_VIS function; // undefined
1438		1449
1439	namespace __function	1450	namespace __function
1440	{	1451	{
...	@@ -1477,6 +1488,12 @@ template <class _Fp>	...	@@ -1477,6 +1488,12 @@ template <class _Fp>
1477	_LIBCPP_INLINE_VISIBILITY	1488	_LIBCPP_INLINE_VISIBILITY
1478	bool __not_null(function<_Fp> const& __f) { return !!__f; }	1489	bool __not_null(function<_Fp> const& __f) { return !!__f; }
1479		1490
		1491	#ifdef _LIBCPP_HAS_EXTENSION_BLOCKS
		1492	template <class _Rp, class ..._Args>
		1493	_LIBCPP_INLINE_VISIBILITY
		1494	bool __not_null(_Rp (^__p)(_Args...)) { return __p; }
		1495	#endif
		1496
1480	} // namespace __function	1497	} // namespace __function
1481		1498
1482	#ifndef _LIBCPP_CXX03_LANG	1499	#ifndef _LIBCPP_CXX03_LANG
...	@@ -1611,7 +1628,7 @@ public:	...	@@ -1611,7 +1628,7 @@ public:
1611		1628
1612	// __base provides an abstract interface for copyable functors.	1629	// __base provides an abstract interface for copyable functors.
1613		1630
1614	template<class _Fp> class __base;	1631	template<class _Fp> class _LIBCPP_TEMPLATE_VIS __base;
1615		1632
1616	template<class _Rp, class ..._ArgTypes>	1633	template<class _Rp, class ..._ArgTypes>
1617	class __base<_Rp(_ArgTypes...)>	1634	class __base<_Rp(_ArgTypes...)>
...	@@ -2238,6 +2255,72 @@ template <class _Rp, class... _ArgTypes> class __policy_func<_Rp(_ArgTypes...)>	...	@@ -2238,6 +2255,72 @@ template <class _Rp, class... _ArgTypes> class __policy_func<_Rp(_ArgTypes...)>
2238	#endif // _LIBCPP_NO_RTTI	2255	#endif // _LIBCPP_NO_RTTI
2239	};	2256	};
2240		2257
		2258	#if defined(_LIBCPP_HAS_BLOCKS_RUNTIME) && !defined(_LIBCPP_HAS_OBJC_ARC)
		2259
		2260	template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
		2261	class __func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>
		2262	: public __base<_Rp(_ArgTypes...)>
		2263	{
		2264	typedef _Rp1(^__block_type)(_ArgTypes1...);
		2265	__block_type __f_;
		2266
		2267	public:
		2268	_LIBCPP_INLINE_VISIBILITY
		2269	explicit __func(__block_type const& __f)
		2270	: __f_(__f ? Block_copy(__f) : (__block_type)0)
		2271	{ }
		2272
		2273	// [TODO] add && to save on a retain
		2274
		2275	_LIBCPP_INLINE_VISIBILITY
		2276	explicit __func(__block_type __f, const _Alloc& /* unused */)
		2277	: __f_(__f ? Block_copy(__f) : (__block_type)0)
		2278	{ }
		2279
		2280	virtual __base<_Rp(_ArgTypes...)>* __clone() const {
		2281	_LIBCPP_ASSERT(false,
		2282	"Block pointers are just pointers, so they should always fit into "
		2283	"std::function's small buffer optimization. This function should "
		2284	"never be invoked.");
		2285	return nullptr;
		2286	}
		2287
		2288	virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const {
		2289	::new (__p) __func(__f_);
		2290	}
		2291
		2292	virtual void destroy() _NOEXCEPT {
		2293	if (__f_)
		2294	Block_release(__f_);
		2295	__f_ = 0;
		2296	}
		2297
		2298	virtual void destroy_deallocate() _NOEXCEPT {
		2299	_LIBCPP_ASSERT(false,
		2300	"Block pointers are just pointers, so they should always fit into "
		2301	"std::function's small buffer optimization. This function should "
		2302	"never be invoked.");
		2303	}
		2304
		2305	virtual _Rp operator()(_ArgTypes&& ... __arg) {
		2306	return __invoke(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
		2307	}
		2308
		2309	#ifndef _LIBCPP_NO_RTTI
		2310	virtual const void* target(type_info const& __ti) const _NOEXCEPT {
		2311	if (__ti == typeid(__func::__block_type))
		2312	return &__f_;
		2313	return (const void*)nullptr;
		2314	}
		2315
		2316	virtual const std::type_info& target_type() const _NOEXCEPT {
		2317	return typeid(__func::__block_type);
		2318	}
		2319	#endif // _LIBCPP_NO_RTTI
		2320	};
		2321
		2322	#endif // _LIBCPP_HAS_EXTENSION_BLOCKS && !_LIBCPP_HAS_OBJC_ARC
		2323
2241	} // __function	2324	} // __function
2242		2325
2243	template<class _Rp, class ..._ArgTypes>	2326	template<class _Rp, class ..._ArgTypes>
...	@@ -2255,14 +2338,14 @@ class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>	...	@@ -2255,14 +2338,14 @@ class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
2255		2338
2256	template <class _Fp, bool = _And<	2339	template <class _Fp, bool = _And<
2257	_IsNotSame<__uncvref_t<_Fp>, function>,	2340	_IsNotSame<__uncvref_t<_Fp>, function>,
2258	__invokable<_Fp&, _ArgTypes...>	2341	__invokable<_Fp, _ArgTypes...>
2259	>::value>	2342	>::value>
2260	struct __callable;	2343	struct __callable;
2261	template <class _Fp>	2344	template <class _Fp>
2262	struct __callable<_Fp, true>	2345	struct __callable<_Fp, true>
2263	{	2346	{
2264	static const bool value = is_same<void, _Rp>::value \|\|	2347	static const bool value = is_same<void, _Rp>::value \|\|
2265	is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,	2348	is_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type,
2266	_Rp>::value;	2349	_Rp>::value;
2267	};	2350	};
2268	template <class _Fp>	2351	template <class _Fp>
...	@@ -2272,7 +2355,7 @@ class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>	...	@@ -2272,7 +2355,7 @@ class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
2272	};	2355	};
2273		2356
2274	template <class _Fp>	2357	template <class _Fp>
2275	using _EnableIfCallable = typename enable_if<__callable<_Fp>::value>::type;	2358	using _EnableIfLValueCallable = typename enable_if<__callable<_Fp&>::value>::type;
2276	public:	2359	public:
2277	typedef _Rp result_type;	2360	typedef _Rp result_type;
2278		2361
...	@@ -2283,7 +2366,7 @@ public:	...	@@ -2283,7 +2366,7 @@ public:
2283	function(nullptr_t) _NOEXCEPT {}	2366	function(nullptr_t) _NOEXCEPT {}
2284	function(const function&);	2367	function(const function&);
2285	function(function&&) _NOEXCEPT;	2368	function(function&&) _NOEXCEPT;
2286	template<class _Fp, class = _EnableIfCallable<_Fp>>	2369	template<class _Fp, class = _EnableIfLValueCallable<_Fp>>
2287	function(_Fp);	2370	function(_Fp);
2288		2371
2289	#if _LIBCPP_STD_VER <= 14	2372	#if _LIBCPP_STD_VER <= 14
...	@@ -2297,14 +2380,14 @@ public:	...	@@ -2297,14 +2380,14 @@ public:
2297	function(allocator_arg_t, const _Alloc&, const function&);	2380	function(allocator_arg_t, const _Alloc&, const function&);
2298	template<class _Alloc>	2381	template<class _Alloc>
2299	function(allocator_arg_t, const _Alloc&, function&&);	2382	function(allocator_arg_t, const _Alloc&, function&&);
2300	template<class _Fp, class _Alloc, class = _EnableIfCallable<_Fp>>	2383	template<class _Fp, class _Alloc, class = _EnableIfLValueCallable<_Fp>>
2301	function(allocator_arg_t, const _Alloc& __a, _Fp __f);	2384	function(allocator_arg_t, const _Alloc& __a, _Fp __f);
2302	#endif	2385	#endif
2303		2386
2304	function& operator=(const function&);	2387	function& operator=(const function&);
2305	function& operator=(function&&) _NOEXCEPT;	2388	function& operator=(function&&) _NOEXCEPT;
2306	function& operator=(nullptr_t) _NOEXCEPT;	2389	function& operator=(nullptr_t) _NOEXCEPT;
2307	template<class _Fp, class = _EnableIfCallable<_Fp>>	2390	template<class _Fp, class = _EnableIfLValueCallable<typename decay<_Fp>::type>>
2308	function& operator=(_Fp&&);	2391	function& operator=(_Fp&&);
2309		2392
2310	~function();	2393	~function();
...	@@ -2967,14 +3050,14 @@ __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,	...	@@ -2967,14 +3050,14 @@ __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
2967	forward_iterator_tag, forward_iterator_tag)	3050	forward_iterator_tag, forward_iterator_tag)
2968	{	3051	{
2969	if (__first2 == __last2)	3052	if (__first2 == __last2)
2970	return make_pair(__first1, __first1); // Everything matches an empty sequence	3053	return _VSTD::make_pair(__first1, __first1); // Everything matches an empty sequence
2971	while (true)	3054	while (true)
2972	{	3055	{
2973	// Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks	3056	// Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
2974	while (true)	3057	while (true)
2975	{	3058	{
2976	if (__first1 == __last1) // return __last1 if no element matches *__first2	3059	if (__first1 == __last1) // return __last1 if no element matches *__first2
2977	return make_pair(__last1, __last1);	3060	return _VSTD::make_pair(__last1, __last1);
2978	if (__pred(__first1, __first2))	3061	if (__pred(__first1, __first2))
2979	break;	3062	break;
2980	++__first1;	3063	++__first1;
...	@@ -2985,9 +3068,9 @@ __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,	...	@@ -2985,9 +3068,9 @@ __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
2985	while (true)	3068	while (true)
2986	{	3069	{
2987	if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern)	3070	if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
2988	return make_pair(__first1, __m1);	3071	return _VSTD::make_pair(__first1, __m1);
2989	if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found	3072	if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found
2990	return make_pair(__last1, __last1);	3073	return _VSTD::make_pair(__last1, __last1);
2991	if (!__pred(__m1, __m2)) // if there is a mismatch, restart with a new __first1	3074	if (!__pred(__m1, __m2)) // if there is a mismatch, restart with a new __first1
2992	{	3075	{
2993	++__first1;	3076	++__first1;
...	@@ -3009,10 +3092,10 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,	...	@@ -3009,10 +3092,10 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
3009	// Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern	3092	// Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
3010	const _D2 __len2 = __last2 - __first2;	3093	const _D2 __len2 = __last2 - __first2;
3011	if (__len2 == 0)	3094	if (__len2 == 0)
3012	return make_pair(__first1, __first1);	3095	return _VSTD::make_pair(__first1, __first1);
3013	const _D1 __len1 = __last1 - __first1;	3096	const _D1 __len1 = __last1 - __first1;
3014	if (__len1 < __len2)	3097	if (__len1 < __len2)
3015	return make_pair(__last1, __last1);	3098	return _VSTD::make_pair(__last1, __last1);
3016	const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here	3099	const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here
3017		3100
3018	while (true)	3101	while (true)
...	@@ -3020,7 +3103,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,	...	@@ -3020,7 +3103,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
3020	while (true)	3103	while (true)
3021	{	3104	{
3022	if (__first1 == __s)	3105	if (__first1 == __s)
3023	return make_pair(__last1, __last1);	3106	return _VSTD::make_pair(__last1, __last1);
3024	if (__pred(__first1, __first2))	3107	if (__pred(__first1, __first2))
3025	break;	3108	break;
3026	++__first1;	3109	++__first1;
...	@@ -3031,7 +3114,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,	...	@@ -3031,7 +3114,7 @@ __search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
3031	while (true)	3114	while (true)
3032	{	3115	{
3033	if (++__m2 == __last2)	3116	if (++__m2 == __last2)
3034	return make_pair(__first1, __first1 + __len2);	3117	return _VSTD::make_pair(__first1, __first1 + __len2);
3035	++__m1; // no need to check range on __m1 because __s guarantees we have enough source	3118	++__m1; // no need to check range on __m1 because __s guarantees we have enough source
3036	if (!__pred(__m1, __m2))	3119	if (!__pred(__m1, __m2))
3037	{	3120	{
...	@@ -3080,15 +3163,19 @@ using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;	...	@@ -3080,15 +3163,19 @@ using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
3080	#endif // > C++17	3163	#endif // > C++17
3081		3164
3082	template <class _Container, class _Predicate>	3165	template <class _Container, class _Predicate>
3083	inline void __libcpp_erase_if_container( _Container& __c, _Predicate __pred)	3166	inline typename _Container::size_type
3084	{	3167	__libcpp_erase_if_container(_Container& __c, _Predicate __pred) {
3085	for (typename _Container::iterator __iter = __c.begin(), __last = __c.end(); __iter != __last;)	3168	typename _Container::size_type __old_size = __c.size();
3086	{	3169
3087	if (__pred(*__iter))	3170	const typename _Container::iterator __last = __c.end();
3088	__iter = __c.erase(__iter);	3171	for (typename _Container::iterator __iter = __c.begin(); __iter != __last;) {
3089	else	3172	if (__pred(*__iter))
3090	++__iter;	3173	__iter = __c.erase(__iter);
3091	}	3174	else
		3175	++__iter;
		3176	}
		3177
		3178	return __old_size - __c.size();
3092	}	3179	}
3093		3180
3094	_LIBCPP_END_NAMESPACE_STD	3181	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/future+1

...	@@ -506,6 +506,7 @@ public:	...	@@ -506,6 +506,7 @@ public:
506	_LIBCPP_INLINE_VISIBILITY	506	_LIBCPP_INLINE_VISIBILITY
507	const error_code& code() const _NOEXCEPT {return __ec_;}	507	const error_code& code() const _NOEXCEPT {return __ec_;}
508		508
		509	future_error(const future_error&) _NOEXCEPT = default;
509	virtual ~future_error() _NOEXCEPT;	510	virtual ~future_error() _NOEXCEPT;
510	};	511	};
511		512

lib/libcxx/include/ios+26-25

...	@@ -431,7 +431,8 @@ class _LIBCPP_EXCEPTION_ABI ios_base::failure	...	@@ -431,7 +431,8 @@ class _LIBCPP_EXCEPTION_ABI ios_base::failure
431	public:	431	public:
432	explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);	432	explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
433	explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);	433	explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
434	virtual ~failure() throw();	434	failure(const failure&) _NOEXCEPT = default;
		435	virtual ~failure() _NOEXCEPT;
435	};	436	};
436		437
437	_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY	438	_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
...	@@ -842,7 +843,7 @@ basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* _	...	@@ -842,7 +843,7 @@ basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* _
842	ios_base::set_rdbuf(__sb);	843	ios_base::set_rdbuf(__sb);
843	}	844	}
844		845
845	inline _LIBCPP_INLINE_VISIBILITY	846	inline
846	ios_base&	847	ios_base&
847	boolalpha(ios_base& __str)	848	boolalpha(ios_base& __str)
848	{	849	{
...	@@ -850,7 +851,7 @@ boolalpha(ios_base& __str)	...	@@ -850,7 +851,7 @@ boolalpha(ios_base& __str)
850	return __str;	851	return __str;
851	}	852	}
852		853
853	inline _LIBCPP_INLINE_VISIBILITY	854	inline
854	ios_base&	855	ios_base&
855	noboolalpha(ios_base& __str)	856	noboolalpha(ios_base& __str)
856	{	857	{
...	@@ -858,7 +859,7 @@ noboolalpha(ios_base& __str)	...	@@ -858,7 +859,7 @@ noboolalpha(ios_base& __str)
858	return __str;	859	return __str;
859	}	860	}
860		861
861	inline _LIBCPP_INLINE_VISIBILITY	862	inline
862	ios_base&	863	ios_base&
863	showbase(ios_base& __str)	864	showbase(ios_base& __str)
864	{	865	{
...	@@ -866,7 +867,7 @@ showbase(ios_base& __str)	...	@@ -866,7 +867,7 @@ showbase(ios_base& __str)
866	return __str;	867	return __str;
867	}	868	}
868		869
869	inline _LIBCPP_INLINE_VISIBILITY	870	inline
870	ios_base&	871	ios_base&
871	noshowbase(ios_base& __str)	872	noshowbase(ios_base& __str)
872	{	873	{
...	@@ -874,7 +875,7 @@ noshowbase(ios_base& __str)	...	@@ -874,7 +875,7 @@ noshowbase(ios_base& __str)
874	return __str;	875	return __str;
875	}	876	}
876		877
877	inline _LIBCPP_INLINE_VISIBILITY	878	inline
878	ios_base&	879	ios_base&
879	showpoint(ios_base& __str)	880	showpoint(ios_base& __str)
880	{	881	{
...	@@ -882,7 +883,7 @@ showpoint(ios_base& __str)	...	@@ -882,7 +883,7 @@ showpoint(ios_base& __str)
882	return __str;	883	return __str;
883	}	884	}
884		885
885	inline _LIBCPP_INLINE_VISIBILITY	886	inline
886	ios_base&	887	ios_base&
887	noshowpoint(ios_base& __str)	888	noshowpoint(ios_base& __str)
888	{	889	{
...	@@ -890,7 +891,7 @@ noshowpoint(ios_base& __str)	...	@@ -890,7 +891,7 @@ noshowpoint(ios_base& __str)
890	return __str;	891	return __str;
891	}	892	}
892		893
893	inline _LIBCPP_INLINE_VISIBILITY	894	inline
894	ios_base&	895	ios_base&
895	showpos(ios_base& __str)	896	showpos(ios_base& __str)
896	{	897	{
...	@@ -898,7 +899,7 @@ showpos(ios_base& __str)	...	@@ -898,7 +899,7 @@ showpos(ios_base& __str)
898	return __str;	899	return __str;
899	}	900	}
900		901
901	inline _LIBCPP_INLINE_VISIBILITY	902	inline
902	ios_base&	903	ios_base&
903	noshowpos(ios_base& __str)	904	noshowpos(ios_base& __str)
904	{	905	{
...	@@ -906,7 +907,7 @@ noshowpos(ios_base& __str)	...	@@ -906,7 +907,7 @@ noshowpos(ios_base& __str)
906	return __str;	907	return __str;
907	}	908	}
908		909
909	inline _LIBCPP_INLINE_VISIBILITY	910	inline
910	ios_base&	911	ios_base&
911	skipws(ios_base& __str)	912	skipws(ios_base& __str)
912	{	913	{
...	@@ -914,7 +915,7 @@ skipws(ios_base& __str)	...	@@ -914,7 +915,7 @@ skipws(ios_base& __str)
914	return __str;	915	return __str;
915	}	916	}
916		917
917	inline _LIBCPP_INLINE_VISIBILITY	918	inline
918	ios_base&	919	ios_base&
919	noskipws(ios_base& __str)	920	noskipws(ios_base& __str)
920	{	921	{
...	@@ -922,7 +923,7 @@ noskipws(ios_base& __str)	...	@@ -922,7 +923,7 @@ noskipws(ios_base& __str)
922	return __str;	923	return __str;
923	}	924	}
924		925
925	inline _LIBCPP_INLINE_VISIBILITY	926	inline
926	ios_base&	927	ios_base&
927	uppercase(ios_base& __str)	928	uppercase(ios_base& __str)
928	{	929	{
...	@@ -930,7 +931,7 @@ uppercase(ios_base& __str)	...	@@ -930,7 +931,7 @@ uppercase(ios_base& __str)
930	return __str;	931	return __str;
931	}	932	}
932		933
933	inline _LIBCPP_INLINE_VISIBILITY	934	inline
934	ios_base&	935	ios_base&
935	nouppercase(ios_base& __str)	936	nouppercase(ios_base& __str)
936	{	937	{
...	@@ -938,7 +939,7 @@ nouppercase(ios_base& __str)	...	@@ -938,7 +939,7 @@ nouppercase(ios_base& __str)
938	return __str;	939	return __str;
939	}	940	}
940		941
941	inline _LIBCPP_INLINE_VISIBILITY	942	inline
942	ios_base&	943	ios_base&
943	unitbuf(ios_base& __str)	944	unitbuf(ios_base& __str)
944	{	945	{
...	@@ -946,7 +947,7 @@ unitbuf(ios_base& __str)	...	@@ -946,7 +947,7 @@ unitbuf(ios_base& __str)
946	return __str;	947	return __str;
947	}	948	}
948		949
949	inline _LIBCPP_INLINE_VISIBILITY	950	inline
950	ios_base&	951	ios_base&
951	nounitbuf(ios_base& __str)	952	nounitbuf(ios_base& __str)
952	{	953	{
...	@@ -954,7 +955,7 @@ nounitbuf(ios_base& __str)	...	@@ -954,7 +955,7 @@ nounitbuf(ios_base& __str)
954	return __str;	955	return __str;
955	}	956	}
956		957
957	inline _LIBCPP_INLINE_VISIBILITY	958	inline
958	ios_base&	959	ios_base&
959	internal(ios_base& __str)	960	internal(ios_base& __str)
960	{	961	{
...	@@ -962,7 +963,7 @@ internal(ios_base& __str)	...	@@ -962,7 +963,7 @@ internal(ios_base& __str)
962	return __str;	963	return __str;
963	}	964	}
964		965
965	inline _LIBCPP_INLINE_VISIBILITY	966	inline
966	ios_base&	967	ios_base&
967	left(ios_base& __str)	968	left(ios_base& __str)
968	{	969	{
...	@@ -970,7 +971,7 @@ left(ios_base& __str)	...	@@ -970,7 +971,7 @@ left(ios_base& __str)
970	return __str;	971	return __str;
971	}	972	}
972		973
973	inline _LIBCPP_INLINE_VISIBILITY	974	inline
974	ios_base&	975	ios_base&
975	right(ios_base& __str)	976	right(ios_base& __str)
976	{	977	{
...	@@ -978,7 +979,7 @@ right(ios_base& __str)	...	@@ -978,7 +979,7 @@ right(ios_base& __str)
978	return __str;	979	return __str;
979	}	980	}
980		981
981	inline _LIBCPP_INLINE_VISIBILITY	982	inline
982	ios_base&	983	ios_base&
983	dec(ios_base& __str)	984	dec(ios_base& __str)
984	{	985	{
...	@@ -986,7 +987,7 @@ dec(ios_base& __str)	...	@@ -986,7 +987,7 @@ dec(ios_base& __str)
986	return __str;	987	return __str;
987	}	988	}
988		989
989	inline _LIBCPP_INLINE_VISIBILITY	990	inline
990	ios_base&	991	ios_base&
991	hex(ios_base& __str)	992	hex(ios_base& __str)
992	{	993	{
...	@@ -994,7 +995,7 @@ hex(ios_base& __str)	...	@@ -994,7 +995,7 @@ hex(ios_base& __str)
994	return __str;	995	return __str;
995	}	996	}
996		997
997	inline _LIBCPP_INLINE_VISIBILITY	998	inline
998	ios_base&	999	ios_base&
999	oct(ios_base& __str)	1000	oct(ios_base& __str)
1000	{	1001	{
...	@@ -1002,7 +1003,7 @@ oct(ios_base& __str)	...	@@ -1002,7 +1003,7 @@ oct(ios_base& __str)
1002	return __str;	1003	return __str;
1003	}	1004	}
1004		1005
1005	inline _LIBCPP_INLINE_VISIBILITY	1006	inline
1006	ios_base&	1007	ios_base&
1007	fixed(ios_base& __str)	1008	fixed(ios_base& __str)
1008	{	1009	{
...	@@ -1010,7 +1011,7 @@ fixed(ios_base& __str)	...	@@ -1010,7 +1011,7 @@ fixed(ios_base& __str)
1010	return __str;	1011	return __str;
1011	}	1012	}
1012		1013
1013	inline _LIBCPP_INLINE_VISIBILITY	1014	inline
1014	ios_base&	1015	ios_base&
1015	scientific(ios_base& __str)	1016	scientific(ios_base& __str)
1016	{	1017	{
...	@@ -1018,7 +1019,7 @@ scientific(ios_base& __str)	...	@@ -1018,7 +1019,7 @@ scientific(ios_base& __str)
1018	return __str;	1019	return __str;
1019	}	1020	}
1020		1021
1021	inline _LIBCPP_INLINE_VISIBILITY	1022	inline
1022	ios_base&	1023	ios_base&
1023	hexfloat(ios_base& __str)	1024	hexfloat(ios_base& __str)
1024	{	1025	{
...	@@ -1026,7 +1027,7 @@ hexfloat(ios_base& __str)	...	@@ -1026,7 +1027,7 @@ hexfloat(ios_base& __str)
1026	return __str;	1027	return __str;
1027	}	1028	}
1028		1029
1029	inline _LIBCPP_INLINE_VISIBILITY	1030	inline
1030	ios_base&	1031	ios_base&
1031	defaultfloat(ios_base& __str)	1032	defaultfloat(ios_base& __str)
1032	{	1033	{

lib/libcxx/include/iterator+10-11

 @@ -54,10 +54,8 @@ struct bidirectional_iterator_tag : public forward_iterator_tag       {};
 struct random_access_iterator_tag : public bidirectional_iterator_tag {};
 // 27.4.3, iterator operations
-// extension: second argument not conforming to C++03
+template <class InputIterator, class Distance>  // constexpr in C++17
-template <class InputIterator>  // constexpr in C++17
+  constexpr void advance(InputIterator& i, Distance n);
-  constexpr void advance(InputIterator& i,
-             typename iterator_traits<InputIterator>::difference_type n);
 template <class InputIterator>  // constexpr in C++17
   constexpr typename iterator_traits<InputIterator>::difference_type
 @@ -663,13 +661,14 @@ void __advance(_RandIter& __i,
    __i += __n;
 }
-template <class _InputIter>
+template <class _InputIter, class _Distance>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-void advance(_InputIter& __i,
+void advance(_InputIter& __i, _Distance __orig_n)
-             typename iterator_traits<_InputIter>::difference_type __n)
 {
-    _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
+    _LIBCPP_ASSERT(__orig_n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
-                       "Attempt to advance(it, -n) on a non-bidi iterator");
+                   "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
+    typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
+    _IntegralSize __n = __orig_n;
     __advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
 }
 @@ -711,7 +710,7 @@ next(_InputIter __x,
      typename iterator_traits<_InputIter>::difference_type __n = 1)
 {
     _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
-                       "Attempt to next(it, -n) on a non-bidi iterator");
+                       "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
     _VSTD::advance(__x, __n);
     return __x;
 @@ -728,7 +727,7 @@ prev(_InputIter __x,
      typename iterator_traits<_InputIter>::difference_type __n = 1)
 {
     _LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
-                       "Attempt to prev(it, +n) on a non-bidi iterator");
+                       "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
     _VSTD::advance(__x, -__n);
     return __x;
 }

lib/libcxx/include/latch created+104

...	@@ -0,0 +1,104 @@
1	// -- C++ --
2	//===--------------------------- latch -----------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP_LATCH
11	#define _LIBCPP_LATCH
12
13	/*
14	latch synopsis
15
16	namespace std
17	{
18
19	class latch
20	{
21	public:
22	constexpr explicit latch(ptrdiff_t __expected);
23	~latch();
24
25	latch(const latch&) = delete;
26	latch& operator=(const latch&) = delete;
27
28	void count_down(ptrdiff_t __update = 1);
29	bool try_wait() const noexcept;
30	void wait() const;
31	void arrive_and_wait(ptrdiff_t __update = 1);
32
33	private:
34	ptrdiff_t __counter; // exposition only
35	};
36
37	}
38
39	*/
40
41	#include <__config>
42	#include <atomic>
43
44	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
45	#pragma GCC system_header
46	#endif
47
48	#ifdef _LIBCPP_HAS_NO_THREADS
49	# error <latch> is not supported on this single threaded system
50	#endif
51
52	#if _LIBCPP_STD_VER >= 14
53
54	_LIBCPP_BEGIN_NAMESPACE_STD
55
56	class latch
57	{
58	__atomic_base<ptrdiff_t> __a;
59
60	public:
61	static constexpr ptrdiff_t max() noexcept {
62	return numeric_limits<ptrdiff_t>::max();
63	}
64
65	inline _LIBCPP_INLINE_VISIBILITY
66	constexpr explicit latch(ptrdiff_t __expected) : __a(__expected) { }
67
68	~latch() = default;
69	latch(const latch&) = delete;
70	latch& operator=(const latch&) = delete;
71
72	inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
73	void count_down(ptrdiff_t __update = 1)
74	{
75	auto const __old = __a.fetch_sub(__update, memory_order_release);
76	if(__old == __update)
77	__a.notify_all();
78	}
79	inline _LIBCPP_INLINE_VISIBILITY
80	bool try_wait() const noexcept
81	{
82	return 0 == __a.load(memory_order_acquire);
83	}
84	inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
85	void wait() const
86	{
87	auto const __test_fn = [=]() -> bool {
88	return try_wait();
89	};
90	__cxx_atomic_wait(&__a.__a_, __test_fn);
91	}
92	inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
93	void arrive_and_wait(ptrdiff_t __update = 1)
94	{
95	count_down(__update);
96	wait();
97	}
98	};
99
100	_LIBCPP_END_NAMESPACE_STD
101
102	#endif // _LIBCPP_STD_VER >= 14
103
104	#endif //_LIBCPP_LATCH

lib/libcxx/include/list+12-8

 @@ -170,9 +170,11 @@ template <class T, class Alloc>
          noexcept(noexcept(x.swap(y)));
 template <class T, class Allocator, class U>
-    void erase(list<T, Allocator>& c, const U& value);       // C++20
+    typename list<T, Allocator>::size_type
+    erase(list<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
+    typename list<T, Allocator>::size_type
+    erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
 }  // std
 @@ -2471,14 +2473,16 @@ swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
-void erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred)
+erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred) {
-{ __c.remove_if(__pred); }
+  return __c.remove_if(__pred);
+}
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
-void erase(list<_Tp, _Allocator>& __c, const _Up& __v)
+erase(list<_Tp, _Allocator>& __c, const _Up& __v) {
-{ _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
+  return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
+}
 #endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/map+17-8

 @@ -254,7 +254,8 @@ swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 template <class Key, class T, class Compare, class Allocator, class Predicate>
-  void erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
+typename map<Key, T, Compare, Allocator>::size_type
+erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 template <class Key, class T, class Compare = less<Key>,
 @@ -469,7 +470,8 @@ swap(multimap<Key, T, Compare, Allocator>& x,
     noexcept(noexcept(x.swap(y)));
 template <class Key, class T, class Compare, class Allocator, class Predicate>
-  void erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
+typename multimap<Key, T, Compare, Allocator>::size_type
+erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 }  // std
 @@ -1653,10 +1655,13 @@ swap(map<_Key, _Tp, _Compare, _Allocator>& __x,
 }
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+template <class _Key, class _Tp, class _Compare, class _Allocator,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred)
+    typename map<_Key, _Tp, _Compare, _Allocator>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 @@ -2235,10 +2240,14 @@ swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x,
 }
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+template <class _Key, class _Tp, class _Compare, class _Allocator,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred)
+    typename multimap<_Key, _Tp, _Compare, _Allocator>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/math.h+5-56

...	@@ -297,9 +297,6 @@ long double truncl(long double x);	...	@@ -297,9 +297,6 @@ long double truncl(long double x);
297	#pragma GCC system_header	297	#pragma GCC system_header
298	#endif	298	#endif
299		299
300	#define _LIBCPP_STDLIB_INCLUDE_NEXT
301	#include <stdlib.h>
302
303	#include_next <math.h>	300	#include_next <math.h>
304		301
305	#ifdef __cplusplus	302	#ifdef __cplusplus
...	@@ -308,6 +305,7 @@ long double truncl(long double x);	...	@@ -308,6 +305,7 @@ long double truncl(long double x);
308	// back to C++ linkage before including these C++ headers.	305	// back to C++ linkage before including these C++ headers.
309	extern "C++" {	306	extern "C++" {
310		307
		308	#include <stdlib.h>
311	#include <type_traits>	309	#include <type_traits>
312	#include <limits>	310	#include <limits>
313		311
...	@@ -760,61 +758,12 @@ isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT	...	@@ -760,61 +758,12 @@ isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
760	#endif // isunordered	758	#endif // isunordered
761		759
762	// abs	760	// abs
763		761	//
764	#undef abs	762	// handled in stdlib.h
765	#undef labs
766	#ifndef _LIBCPP_HAS_NO_LONG_LONG
767	#undef llabs
768	#endif
769
770	// MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
771	#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
772	inline _LIBCPP_INLINE_VISIBILITY long abs(long __x) _NOEXCEPT {
773	return ::labs(__x);
774	}
775	#ifndef _LIBCPP_HAS_NO_LONG_LONG
776	inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {
777	return ::llabs(__x);
778	}
779	#endif // _LIBCPP_HAS_NO_LONG_LONG
780	#endif // !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
781
782
783	#if !(defined(_AIX) \|\| defined(__sun__))
784	inline _LIBCPP_INLINE_VISIBILITY float abs(float __lcpp_x) _NOEXCEPT {
785	return ::fabsf(__lcpp_x);
786	}
787
788	inline _LIBCPP_INLINE_VISIBILITY double abs(double __lcpp_x) _NOEXCEPT {
789	return ::fabs(__lcpp_x);
790	}
791
792	inline _LIBCPP_INLINE_VISIBILITY long double
793	abs(long double __lcpp_x) _NOEXCEPT {
794	return ::fabsl(__lcpp_x);
795	}
796	#endif // !(defined(_AIX) \|\| defined(__sun__))
797		763
798	// div	764	// div
799		765	//
800	#undef div	766	// handled in stdlib.h
801	#undef ldiv
802	#ifndef _LIBCPP_HAS_NO_LONG_LONG
803	#undef lldiv
804	#endif
805
806	// MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
807	#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
808	inline _LIBCPP_INLINE_VISIBILITY ldiv_t div(long __x, long __y) _NOEXCEPT {
809	return ::ldiv(__x, __y);
810	}
811	#ifndef _LIBCPP_HAS_NO_LONG_LONG
812	inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x,
813	long long __y) _NOEXCEPT {
814	return ::lldiv(__x, __y);
815	}
816	#endif // _LIBCPP_HAS_NO_LONG_LONG
817	#endif // _LIBCPP_MSVCRT / __sun__ / _AIX
818		767
819	// acos	768	// acos
820		769

lib/libcxx/include/memory+290-382

...	@@ -80,7 +80,7 @@ struct allocator_traits	...	@@ -80,7 +80,7 @@ struct allocator_traits
80	typedef Alloc::is_always_equal	80	typedef Alloc::is_always_equal
81	\| is_empty is_always_equal;	81	\| is_empty is_always_equal;
82		82
83	template <class T> using rebind_alloc = Alloc::rebind<U>::other \| Alloc<T, Args...>;	83	template <class T> using rebind_alloc = Alloc::rebind<T>::other \| Alloc<T, Args...>;
84	template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;	84	template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
85		85
86	static pointer allocate(allocator_type& a, size_type n); // [[nodiscard]] in C++20	86	static pointer allocate(allocator_type& a, size_type n); // [[nodiscard]] in C++20
...	@@ -101,7 +101,7 @@ struct allocator_traits	...	@@ -101,7 +101,7 @@ struct allocator_traits
101	};	101	};
102		102
103	template <>	103	template <>
104	class allocator<void>	104	class allocator<void> // deprecated in C++17, removed in C++20
105	{	105	{
106	public:	106	public:
107	typedef void* pointer;	107	typedef void* pointer;
...	@@ -115,30 +115,37 @@ template <class T>	...	@@ -115,30 +115,37 @@ template <class T>
115	class allocator	115	class allocator
116	{	116	{
117	public:	117	public:
118	typedef size_t size_type;	118	typedef size_t size_type; // deprecated in C++17, removed in C++20
119	typedef ptrdiff_t difference_type;	119	typedef ptrdiff_t difference_type; // deprecated in C++17, removed in C++20
120	typedef T* pointer;	120	typedef T* pointer; // deprecated in C++17, removed in C++20
121	typedef const T* const_pointer;	121	typedef const T* const_pointer; // deprecated in C++17, removed in C++20
122	typedef typename add_lvalue_reference<T>::type reference;	122	typedef typename add_lvalue_reference<T>::type
123	typedef typename add_lvalue_reference<const T>::type const_reference;	123	reference; // deprecated in C++17, removed in C++20
124	typedef T value_type;	124	typedef typename add_lvalue_reference<const T>::type
		125	const_reference; // deprecated in C++17, removed in C++20
125		126
126	template <class U> struct rebind {typedef allocator<U> other;};	127	typedef T value_type;
		128
		129	template <class U> struct rebind {typedef allocator<U> other;}; // deprecated in C++17, removed in C++20
		130
		131	typedef true_type propagate_on_container_move_assignment;
		132	typedef true_type is_always_equal;
127		133
128	constexpr allocator() noexcept; // constexpr in C++20	134	constexpr allocator() noexcept; // constexpr in C++20
129	constexpr allocator(const allocator&) noexcept; // constexpr in C++20	135	constexpr allocator(const allocator&) noexcept; // constexpr in C++20
130	template <class U>	136	template <class U>
131	constexpr allocator(const allocator<U>&) noexcept; // constexpr in C++20	137	constexpr allocator(const allocator<U>&) noexcept; // constexpr in C++20
132	~allocator();	138	~allocator();
133	pointer address(reference x) const noexcept;	139	pointer address(reference x) const noexcept; // deprecated in C++17, removed in C++20
134	const_pointer address(const_reference x) const noexcept;	140	const_pointer address(const_reference x) const noexcept; // deprecated in C++17, removed in C++20
135	pointer allocate(size_type, allocator<void>::const_pointer hint = 0);	141	T* allocate(size_t n, const void* hint); // deprecated in C++17, removed in C++20
136	void deallocate(pointer p, size_type n) noexcept;	142	T* allocate(size_t n);
137	size_type max_size() const noexcept;	143	void deallocate(T* p, size_t n) noexcept;
		144	size_type max_size() const noexcept; // deprecated in C++17, removed in C++20
138	template<class U, class... Args>	145	template<class U, class... Args>
139	void construct(U* p, Args&&... args);	146	void construct(U* p, Args&&... args); // deprecated in C++17, removed in C++20
140	template <class U>	147	template <class U>
141	void destroy(U* p);	148	void destroy(U* p); // deprecated in C++17, removed in C++20
142	};	149	};
143		150
144	template <class T, class U>	151	template <class T, class U>
...	@@ -443,6 +450,11 @@ public:	...	@@ -443,6 +450,11 @@ public:
443	template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;	450	template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;
444	};	451	};
445		452
		453	template<class T>
		454	shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
		455	template<class T, class D>
		456	shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
		457
446	// shared_ptr comparisons:	458	// shared_ptr comparisons:
447	template<class T, class U>	459	template<class T, class U>
448	bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;	460	bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
...	@@ -541,6 +553,9 @@ public:	...	@@ -541,6 +553,9 @@ public:
541	template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;	553	template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;
542	};	554	};
543		555
		556	template<class T>
		557	weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
		558
544	// weak_ptr specialized algorithms:	559	// weak_ptr specialized algorithms:
545	template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;	560	template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
546		561
...	@@ -705,8 +720,9 @@ _ValueType __libcpp_acquire_load(_ValueType const* __value) {	...	@@ -705,8 +720,9 @@ _ValueType __libcpp_acquire_load(_ValueType const* __value) {
705		720
706	template <class _Tp> class allocator;	721	template <class _Tp> class allocator;
707		722
		723	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
708	template <>	724	template <>
709	class _LIBCPP_TEMPLATE_VIS allocator<void>	725	class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<void>
710	{	726	{
711	public:	727	public:
712	typedef void* pointer;	728	typedef void* pointer;
...	@@ -717,7 +733,7 @@ public:	...	@@ -717,7 +733,7 @@ public:
717	};	733	};
718		734
719	template <>	735	template <>
720	class _LIBCPP_TEMPLATE_VIS allocator<const void>	736	class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<const void>
721	{	737	{
722	public:	738	public:
723	typedef const void* pointer;	739	typedef const void* pointer;
...	@@ -726,6 +742,7 @@ public:	...	@@ -726,6 +742,7 @@ public:
726		742
727	template <class _Up> struct rebind {typedef allocator<_Up> other;};	743	template <class _Up> struct rebind {typedef allocator<_Up> other;};
728	};	744	};
		745	#endif
729		746
730	// pointer_traits	747	// pointer_traits
731		748
...	@@ -838,7 +855,9 @@ struct __has_rebind	...	@@ -838,7 +855,9 @@ struct __has_rebind
838	private:	855	private:
839	struct __two {char __lx; char __lxx;};	856	struct __two {char __lx; char __lxx;};
840	template <class _Xp> static __two __test(...);	857	template <class _Xp> static __two __test(...);
		858	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
841	template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);	859	template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
		860	_LIBCPP_SUPPRESS_DEPRECATED_POP
842	public:	861	public:
843	static const bool value = sizeof(__test<_Tp>(0)) == 1;	862	static const bool value = sizeof(__test<_Tp>(0)) == 1;
844	};	863	};
...	@@ -1266,7 +1285,9 @@ struct __has_rebind_other	...	@@ -1266,7 +1285,9 @@ struct __has_rebind_other
1266	private:	1285	private:
1267	struct __two {char __lx; char __lxx;};	1286	struct __two {char __lx; char __lxx;};
1268	template <class _Xp> static __two __test(...);	1287	template <class _Xp> static __two __test(...);
		1288	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1269	template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0);	1289	template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0);
		1290	_LIBCPP_SUPPRESS_DEPRECATED_POP
1270	public:	1291	public:
1271	static const bool value = sizeof(__test<_Tp>(0)) == 1;	1292	static const bool value = sizeof(__test<_Tp>(0)) == 1;
1272	};	1293	};
...	@@ -1280,15 +1301,17 @@ struct __has_rebind_other<_Tp, _Up, false>	...	@@ -1280,15 +1301,17 @@ struct __has_rebind_other<_Tp, _Up, false>
1280	template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>	1301	template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
1281	struct __allocator_traits_rebind	1302	struct __allocator_traits_rebind
1282	{	1303	{
		1304	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1283	typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;	1305	typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;
		1306	_LIBCPP_SUPPRESS_DEPRECATED_POP
1284	};	1307	};
1285		1308
1286	#ifndef _LIBCPP_HAS_NO_VARIADICS
1287
1288	template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>	1309	template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
1289	struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>	1310	struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>
1290	{	1311	{
		1312	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1291	typedef _LIBCPP_NODEBUG_TYPE typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type;	1313	typedef _LIBCPP_NODEBUG_TYPE typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type;
		1314	_LIBCPP_SUPPRESS_DEPRECATED_POP
1292	};	1315	};
1293		1316
1294	template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>	1317	template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
...	@@ -1297,68 +1320,14 @@ struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>	...	@@ -1297,68 +1320,14 @@ struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>
1297	typedef _LIBCPP_NODEBUG_TYPE _Alloc<_Up, _Args...> type;	1320	typedef _LIBCPP_NODEBUG_TYPE _Alloc<_Up, _Args...> type;
1298	};	1321	};
1299		1322
1300	#else // _LIBCPP_HAS_NO_VARIADICS
1301
1302	template <template <class> class _Alloc, class _Tp, class _Up>
1303	struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, true>
1304	{
1305	typedef typename _Alloc<_Tp>::template rebind<_Up>::other type;
1306	};
1307
1308	template <template <class> class _Alloc, class _Tp, class _Up>
1309	struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, false>
1310	{
1311	typedef _Alloc<_Up> type;
1312	};
1313
1314	template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up>
1315	struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, true>
1316	{
1317	typedef typename _Alloc<_Tp, _A0>::template rebind<_Up>::other type;
1318	};
1319
1320	template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up>
1321	struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, false>
1322	{
1323	typedef _Alloc<_Up, _A0> type;
1324	};
1325
1326	template <template <class, class, class> class _Alloc, class _Tp, class _A0,
1327	class _A1, class _Up>
1328	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, true>
1329	{
1330	typedef typename _Alloc<_Tp, _A0, _A1>::template rebind<_Up>::other type;
1331	};
1332
1333	template <template <class, class, class> class _Alloc, class _Tp, class _A0,
1334	class _A1, class _Up>
1335	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, false>
1336	{
1337	typedef _Alloc<_Up, _A0, _A1> type;
1338	};
1339
1340	template <template <class, class, class, class> class _Alloc, class _Tp, class _A0,
1341	class _A1, class _A2, class _Up>
1342	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, true>
1343	{
1344	typedef typename _Alloc<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type;
1345	};
1346
1347	template <template <class, class, class, class> class _Alloc, class _Tp, class _A0,
1348	class _A1, class _A2, class _Up>
1349	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false>
1350	{
1351	typedef _Alloc<_Up, _A0, _A1, _A2> type;
1352	};
1353
1354	#endif // _LIBCPP_HAS_NO_VARIADICS
1355
1356	#ifndef _LIBCPP_CXX03_LANG	1323	#ifndef _LIBCPP_CXX03_LANG
1357		1324
		1325	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1358	template <class _Alloc, class _SizeType, class _ConstVoidPtr>	1326	template <class _Alloc, class _SizeType, class _ConstVoidPtr>
1359	auto	1327	auto
1360	__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)	1328	__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
1361	-> decltype((void)__a.allocate(__sz, __p), true_type());	1329	-> decltype((void)__a.allocate(__sz, __p), true_type());
		1330	_LIBCPP_SUPPRESS_DEPRECATED_POP
1362		1331
1363	template <class _Alloc, class _SizeType, class _ConstVoidPtr>	1332	template <class _Alloc, class _SizeType, class _ConstVoidPtr>
1364	auto	1333	auto
...	@@ -1367,12 +1336,9 @@ __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __	...	@@ -1367,12 +1336,9 @@ __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __
1367		1336
1368	template <class _Alloc, class _SizeType, class _ConstVoidPtr>	1337	template <class _Alloc, class _SizeType, class _ConstVoidPtr>
1369	struct __has_allocate_hint	1338	struct __has_allocate_hint
1370	: integral_constant<bool,	1339	: decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
1371	is_same<	1340	declval<_SizeType>(),
1372	decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),	1341	declval<_ConstVoidPtr>()))
1373	declval<_SizeType>(),
1374	declval<_ConstVoidPtr>())),
1375	true_type>::value>
1376	{	1342	{
1377	};	1343	};
1378		1344
...	@@ -1386,33 +1352,26 @@ struct __has_allocate_hint	...	@@ -1386,33 +1352,26 @@ struct __has_allocate_hint
1386		1352
1387	#endif // _LIBCPP_CXX03_LANG	1353	#endif // _LIBCPP_CXX03_LANG
1388		1354
1389	#if !defined(_LIBCPP_CXX03_LANG)	1355	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
		1356	template <class _Alloc, class ..._Args,
		1357	class = decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Args>()...))>
		1358	static true_type __test_has_construct(int);
		1359	_LIBCPP_SUPPRESS_DEPRECATED_POP
1390		1360
1391	template <class _Alloc, class _Tp, class ..._Args>	1361	template <class _Alloc, class...>
1392	decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(),	1362	static false_type __test_has_construct(...);
1393	_VSTD::declval<_Args>()...),	1363
1394	true_type())	1364	template <class _Alloc, class ..._Args>
1395	__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);	1365	struct __has_construct : decltype(__test_has_construct<_Alloc, _Args...>(0)) {};
1396		1366
1397	template <class _Alloc, class _Pointer, class ..._Args>	1367	#if !defined(_LIBCPP_CXX03_LANG)
1398	false_type
1399	__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args);
1400
1401	template <class _Alloc, class _Pointer, class ..._Args>
1402	struct __has_construct
1403	: integral_constant<bool,
1404	is_same<
1405	decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
1406	declval<_Pointer>(),
1407	declval<_Args>()...)),
1408	true_type>::value>
1409	{
1410	};
1411		1368
		1369	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1412	template <class _Alloc, class _Pointer>	1370	template <class _Alloc, class _Pointer>
1413	auto	1371	auto
1414	__has_destroy_test(_Alloc&& __a, _Pointer&& __p)	1372	__has_destroy_test(_Alloc&& __a, _Pointer&& __p)
1415	-> decltype(__a.destroy(__p), true_type());	1373	-> decltype(__a.destroy(__p), true_type());
		1374	_LIBCPP_SUPPRESS_DEPRECATED_POP
1416		1375
1417	template <class _Alloc, class _Pointer>	1376	template <class _Alloc, class _Pointer>
1418	auto	1377	auto
...	@@ -1421,18 +1380,17 @@ __has_destroy_test(const _Alloc& __a, _Pointer&& __p)	...	@@ -1421,18 +1380,17 @@ __has_destroy_test(const _Alloc& __a, _Pointer&& __p)
1421		1380
1422	template <class _Alloc, class _Pointer>	1381	template <class _Alloc, class _Pointer>
1423	struct __has_destroy	1382	struct __has_destroy
1424	: integral_constant<bool,	1383	: decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
1425	is_same<	1384	declval<_Pointer>()))
1426	decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
1427	declval<_Pointer>())),
1428	true_type>::value>
1429	{	1385	{
1430	};	1386	};
1431		1387
		1388	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1432	template <class _Alloc>	1389	template <class _Alloc>
1433	auto	1390	auto
1434	__has_max_size_test(_Alloc&& __a)	1391	__has_max_size_test(_Alloc&& __a)
1435	-> decltype(__a.max_size(), true_type());	1392	-> decltype(__a.max_size(), true_type());
		1393	_LIBCPP_SUPPRESS_DEPRECATED_POP
1436		1394
1437	template <class _Alloc>	1395	template <class _Alloc>
1438	auto	1396	auto
...	@@ -1441,10 +1399,7 @@ __has_max_size_test(const volatile _Alloc& __a)	...	@@ -1441,10 +1399,7 @@ __has_max_size_test(const volatile _Alloc& __a)
1441		1399
1442	template <class _Alloc>	1400	template <class _Alloc>
1443	struct __has_max_size	1401	struct __has_max_size
1444	: integral_constant<bool,	1402	: decltype(_VSTD::__has_max_size_test(declval<_Alloc&>()))
1445	is_same<
1446	decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())),
1447	true_type>::value>
1448	{	1403	{
1449	};	1404	};
1450		1405
...	@@ -1460,23 +1415,12 @@ __has_select_on_container_copy_construction_test(const volatile _Alloc& __a)	...	@@ -1460,23 +1415,12 @@ __has_select_on_container_copy_construction_test(const volatile _Alloc& __a)
1460		1415
1461	template <class _Alloc>	1416	template <class _Alloc>
1462	struct __has_select_on_container_copy_construction	1417	struct __has_select_on_container_copy_construction
1463	: integral_constant<bool,	1418	: decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>()))
1464	is_same<
1465	decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
1466	true_type>::value>
1467	{	1419	{
1468	};	1420	};
1469		1421
1470	#else // _LIBCPP_CXX03_LANG	1422	#else // _LIBCPP_CXX03_LANG
1471		1423
1472	template <class _Alloc, class _Pointer, class _Tp, class = void>
1473	struct __has_construct : std::false_type {};
1474
1475	template <class _Alloc, class _Pointer, class _Tp>
1476	struct __has_construct<_Alloc, _Pointer, _Tp, typename __void_t<
1477	decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Pointer>(), _VSTD::declval<_Tp>()))
1478	>::type> : std::true_type {};
1479
1480	template <class _Alloc, class _Pointer, class = void>	1424	template <class _Alloc, class _Pointer, class = void>
1481	struct __has_destroy : false_type {};	1425	struct __has_destroy : false_type {};
1482		1426
...	@@ -1588,41 +1532,11 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits	...	@@ -1588,41 +1532,11 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
1588	static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT	1532	static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT
1589	{__a.deallocate(__p, __n);}	1533	{__a.deallocate(__p, __n);}
1590		1534
1591	#ifndef _LIBCPP_HAS_NO_VARIADICS
1592	template <class _Tp, class... _Args>	1535	template <class _Tp, class... _Args>
1593	_LIBCPP_INLINE_VISIBILITY	1536	_LIBCPP_INLINE_VISIBILITY
1594	static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)	1537	static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
1595	{__construct(__has_construct<allocator_type, _Tp*, _Args...>(),	1538	{__construct(__has_construct<allocator_type, _Tp*, _Args...>(),
1596	__a, __p, _VSTD::forward<_Args>(__args)...);}	1539	__a, __p, _VSTD::forward<_Args>(__args)...);}
1597	#else // _LIBCPP_HAS_NO_VARIADICS
1598	template <class _Tp>
1599	_LIBCPP_INLINE_VISIBILITY
1600	static void construct(allocator_type&, _Tp* __p)
1601	{
1602	::new ((void*)__p) _Tp();
1603	}
1604	template <class _Tp, class _A0>
1605	_LIBCPP_INLINE_VISIBILITY
1606	static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0)
1607	{
1608	__construct(__has_construct<allocator_type, _Tp*, const _A0&>(),
1609	__a, __p, __a0);
1610	}
1611	template <class _Tp, class _A0, class _A1>
1612	_LIBCPP_INLINE_VISIBILITY
1613	static void construct(allocator_type&, _Tp* __p, const _A0& __a0,
1614	const _A1& __a1)
1615	{
1616	::new ((void*)__p) _Tp(__a0, __a1);
1617	}
1618	template <class _Tp, class _A0, class _A1, class _A2>
1619	_LIBCPP_INLINE_VISIBILITY
1620	static void construct(allocator_type&, _Tp* __p, const _A0& __a0,
1621	const _A1& __a1, const _A2& __a2)
1622	{
1623	::new ((void*)__p) _Tp(__a0, __a1, __a2);
1624	}
1625	#endif // _LIBCPP_HAS_NO_VARIADICS
1626		1540
1627	template <class _Tp>	1541	template <class _Tp>
1628	_LIBCPP_INLINE_VISIBILITY	1542	_LIBCPP_INLINE_VISIBILITY
...	@@ -1695,7 +1609,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits	...	@@ -1695,7 +1609,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
1695	static	1609	static
1696	typename enable_if	1610	typename enable_if
1697	<	1611	<
1698	is_trivially_move_constructible<_DestTp>::value &&	1612	is_trivially_copy_constructible<_DestTp>::value &&
1699	is_same<_RawSourceTp, _RawDestTp>::value &&	1613	is_same<_RawSourceTp, _RawDestTp>::value &&
1700	(__is_default_allocator<allocator_type>::value \|\|	1614	(__is_default_allocator<allocator_type>::value \|\|
1701	!__has_construct<allocator_type, _DestTp*, _SourceTp&>::value),	1615	!__has_construct<allocator_type, _DestTp*, _SourceTp&>::value),
...	@@ -1755,42 +1669,40 @@ private:	...	@@ -1755,42 +1669,40 @@ private:
1755	_LIBCPP_INLINE_VISIBILITY	1669	_LIBCPP_INLINE_VISIBILITY
1756	static pointer __allocate(allocator_type& __a, size_type __n,	1670	static pointer __allocate(allocator_type& __a, size_type __n,
1757	const_void_pointer __hint, true_type)	1671	const_void_pointer __hint, true_type)
1758	{return __a.allocate(__n, __hint);}	1672	{
		1673	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
		1674	return __a.allocate(__n, __hint);
		1675	_LIBCPP_SUPPRESS_DEPRECATED_POP
		1676	}
1759	_LIBCPP_INLINE_VISIBILITY	1677	_LIBCPP_INLINE_VISIBILITY
1760	static pointer __allocate(allocator_type& __a, size_type __n,	1678	static pointer __allocate(allocator_type& __a, size_type __n,
1761	const_void_pointer, false_type)	1679	const_void_pointer, false_type)
1762	{return __a.allocate(__n);}	1680	{return __a.allocate(__n);}
1763		1681
1764	#ifndef _LIBCPP_HAS_NO_VARIADICS
1765	template <class _Tp, class... _Args>	1682	template <class _Tp, class... _Args>
1766	_LIBCPP_INLINE_VISIBILITY	1683	_LIBCPP_INLINE_VISIBILITY
1767	static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)	1684	static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
1768	{__a.construct(__p, _VSTD::forward<_Args>(__args)...);}	1685	{
		1686	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
		1687	__a.construct(__p, _VSTD::forward<_Args>(__args)...);
		1688	_LIBCPP_SUPPRESS_DEPRECATED_POP
		1689	}
		1690
1769	template <class _Tp, class... _Args>	1691	template <class _Tp, class... _Args>
1770	_LIBCPP_INLINE_VISIBILITY	1692	_LIBCPP_INLINE_VISIBILITY
1771	static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)	1693	static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
1772	{	1694	{
1773	::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);	1695	::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
1774	}	1696	}
1775	#else // _LIBCPP_HAS_NO_VARIADICS
1776	template <class _Tp, class _A0>
1777	_LIBCPP_INLINE_VISIBILITY
1778	static void __construct(true_type, allocator_type& __a, _Tp* __p,
1779	const _A0& __a0)
1780	{__a.construct(__p, __a0);}
1781	template <class _Tp, class _A0>
1782	_LIBCPP_INLINE_VISIBILITY
1783	static void __construct(false_type, allocator_type&, _Tp* __p,
1784	const _A0& __a0)
1785	{
1786	::new ((void*)__p) _Tp(__a0);
1787	}
1788	#endif // _LIBCPP_HAS_NO_VARIADICS
1789		1697
1790	template <class _Tp>	1698	template <class _Tp>
1791	_LIBCPP_INLINE_VISIBILITY	1699	_LIBCPP_INLINE_VISIBILITY
1792	static void __destroy(true_type, allocator_type& __a, _Tp* __p)	1700	static void __destroy(true_type, allocator_type& __a, _Tp* __p)
1793	{__a.destroy(__p);}	1701	{
		1702	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
		1703	__a.destroy(__p);
		1704	_LIBCPP_SUPPRESS_DEPRECATED_POP
		1705	}
1794	template <class _Tp>	1706	template <class _Tp>
1795	_LIBCPP_INLINE_VISIBILITY	1707	_LIBCPP_INLINE_VISIBILITY
1796	static void __destroy(false_type, allocator_type&, _Tp* __p)	1708	static void __destroy(false_type, allocator_type&, _Tp* __p)
...	@@ -1800,7 +1712,12 @@ private:	...	@@ -1800,7 +1712,12 @@ private:
1800		1712
1801	_LIBCPP_INLINE_VISIBILITY	1713	_LIBCPP_INLINE_VISIBILITY
1802	static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT	1714	static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT
1803	{return __a.max_size();}	1715	{
		1716	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
		1717	return __a.max_size();
		1718	_LIBCPP_SUPPRESS_DEPRECATED_POP
		1719	}
		1720
1804	_LIBCPP_INLINE_VISIBILITY	1721	_LIBCPP_INLINE_VISIBILITY
1805	static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT	1722	static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT
1806	{return numeric_limits<size_type>::max() / sizeof(value_type);}	1723	{return numeric_limits<size_type>::max() / sizeof(value_type);}
...	@@ -1831,19 +1748,22 @@ template <class _Tp>	...	@@ -1831,19 +1748,22 @@ template <class _Tp>
1831	class _LIBCPP_TEMPLATE_VIS allocator	1748	class _LIBCPP_TEMPLATE_VIS allocator
1832	{	1749	{
1833	public:	1750	public:
1834	typedef size_t size_type;	1751	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
1835	typedef ptrdiff_t difference_type;	1752	_LIBCPP_DEPRECATED_IN_CXX17 typedef size_t size_type;
1836	typedef _Tp* pointer;	1753	_LIBCPP_DEPRECATED_IN_CXX17 typedef ptrdiff_t difference_type;
1837	typedef const _Tp* const_pointer;	1754	_LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp* pointer;
1838	typedef _Tp& reference;	1755	_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
1839	typedef const _Tp& const_reference;	1756	_LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp& reference;
1840	typedef _Tp value_type;	1757	_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
		1758
		1759	template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
		1760	#endif
		1761
		1762	typedef _Tp value_type;
1841		1763
1842	typedef true_type propagate_on_container_move_assignment;	1764	typedef true_type propagate_on_container_move_assignment;
1843	typedef true_type is_always_equal;	1765	typedef true_type is_always_equal;
1844		1766
1845	template <class _Up> struct rebind {typedef allocator<_Up> other;};
1846
1847	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17	1767	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1848	allocator() _NOEXCEPT {}	1768	allocator() _NOEXCEPT {}
1849		1769
...	@@ -1851,103 +1771,67 @@ public:	...	@@ -1851,103 +1771,67 @@ public:
1851	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17	1771	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1852	allocator(const allocator<_Up>&) _NOEXCEPT {}	1772	allocator(const allocator<_Up>&) _NOEXCEPT {}
1853		1773
1854	_LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT	1774	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
		1775	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
		1776	pointer address(reference __x) const _NOEXCEPT
1855	{return _VSTD::addressof(__x);}	1777	{return _VSTD::addressof(__x);}
1856	_LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT	1778	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
		1779	const_pointer address(const_reference __x) const _NOEXCEPT
1857	{return _VSTD::addressof(__x);}	1780	{return _VSTD::addressof(__x);}
1858	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY	1781	#endif
1859	pointer allocate(size_type __n, allocator<void>::const_pointer = 0)	1782
		1783	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _Tp* allocate(size_t __n)
1860	{	1784	{
1861	if (__n > max_size())	1785	// TODO(mpark): Replace with `allocator_traits<allocator>::max_size(*this)`.
		1786	if (__n > (size_t(~0) / sizeof(_Tp)))
1862	__throw_length_error("allocator<T>::allocate(size_t n)"	1787	__throw_length_error("allocator<T>::allocate(size_t n)"
1863	" 'n' exceeds maximum supported size");	1788	" 'n' exceeds maximum supported size");
1864	return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));	1789	return static_cast<_Tp>(_VSTD::__libcpp_allocate(__n sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
1865	}	1790	}
1866	_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT	1791
		1792	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
		1793	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
		1794	_Tp* allocate(size_t __n, const void*) { return allocate(__n); }
		1795	#endif
		1796
		1797	_LIBCPP_INLINE_VISIBILITY void deallocate(_Tp* __p, size_t __n) _NOEXCEPT
1867	{_VSTD::__libcpp_deallocate((void)__p, __n sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}	1798	{_VSTD::__libcpp_deallocate((void)__p, __n sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
1868	_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT	1799
		1800	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
		1801	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
1869	{return size_type(~0) / sizeof(_Tp);}	1802	{return size_type(~0) / sizeof(_Tp);}
1870	#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)	1803
1871	template <class _Up, class... _Args>	1804	template <class _Up, class... _Args>
1872	_LIBCPP_INLINE_VISIBILITY	1805	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
1873	void	1806	void
1874	construct(_Up* __p, _Args&&... __args)	1807	construct(_Up* __p, _Args&&... __args)
1875	{	1808	{
1876	::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);	1809	::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
1877	}	1810	}
1878	#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)	1811	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
1879	_LIBCPP_INLINE_VISIBILITY	1812	#endif
1880	void
1881	construct(pointer __p)
1882	{
1883	::new((void*)__p) _Tp();
1884	}
1885	# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
1886
1887	template <class _A0>
1888	_LIBCPP_INLINE_VISIBILITY
1889	void
1890	construct(pointer __p, _A0& __a0)
1891	{
1892	::new((void*)__p) _Tp(__a0);
1893	}
1894	template <class _A0>
1895	_LIBCPP_INLINE_VISIBILITY
1896	void
1897	construct(pointer __p, const _A0& __a0)
1898	{
1899	::new((void*)__p) _Tp(__a0);
1900	}
1901	# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
1902	template <class _A0, class _A1>
1903	_LIBCPP_INLINE_VISIBILITY
1904	void
1905	construct(pointer __p, _A0& __a0, _A1& __a1)
1906	{
1907	::new((void*)__p) _Tp(__a0, __a1);
1908	}
1909	template <class _A0, class _A1>
1910	_LIBCPP_INLINE_VISIBILITY
1911	void
1912	construct(pointer __p, const _A0& __a0, _A1& __a1)
1913	{
1914	::new((void*)__p) _Tp(__a0, __a1);
1915	}
1916	template <class _A0, class _A1>
1917	_LIBCPP_INLINE_VISIBILITY
1918	void
1919	construct(pointer __p, _A0& __a0, const _A1& __a1)
1920	{
1921	::new((void*)__p) _Tp(__a0, __a1);
1922	}
1923	template <class _A0, class _A1>
1924	_LIBCPP_INLINE_VISIBILITY
1925	void
1926	construct(pointer __p, const _A0& __a0, const _A1& __a1)
1927	{
1928	::new((void*)__p) _Tp(__a0, __a1);
1929	}
1930	#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
1931	_LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
1932	};	1813	};
1933		1814
1934	template <class _Tp>	1815	template <class _Tp>
1935	class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>	1816	class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
1936	{	1817	{
1937	public:	1818	public:
1938	typedef size_t size_type;	1819	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
1939	typedef ptrdiff_t difference_type;	1820	_LIBCPP_DEPRECATED_IN_CXX17 typedef size_t size_type;
1940	typedef const _Tp* pointer;	1821	_LIBCPP_DEPRECATED_IN_CXX17 typedef ptrdiff_t difference_type;
1941	typedef const _Tp* const_pointer;	1822	_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* pointer;
1942	typedef const _Tp& reference;	1823	_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
1943	typedef const _Tp& const_reference;	1824	_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& reference;
1944	typedef const _Tp value_type;	1825	_LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
		1826
		1827	template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
		1828	#endif
		1829
		1830	typedef const _Tp value_type;
1945		1831
1946	typedef true_type propagate_on_container_move_assignment;	1832	typedef true_type propagate_on_container_move_assignment;
1947	typedef true_type is_always_equal;	1833	typedef true_type is_always_equal;
1948		1834
1949	template <class _Up> struct rebind {typedef allocator<_Up> other;};
1950
1951	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17	1835	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1952	allocator() _NOEXCEPT {}	1836	allocator() _NOEXCEPT {}
1953		1837
...	@@ -1955,22 +1839,36 @@ public:	...	@@ -1955,22 +1839,36 @@ public:
1955	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17	1839	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1956	allocator(const allocator<_Up>&) _NOEXCEPT {}	1840	allocator(const allocator<_Up>&) _NOEXCEPT {}
1957		1841
1958	_LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT	1842	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
		1843	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
		1844	const_pointer address(const_reference __x) const _NOEXCEPT
1959	{return _VSTD::addressof(__x);}	1845	{return _VSTD::addressof(__x);}
1960	_LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)	1846	#endif
		1847
		1848	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const _Tp* allocate(size_t __n)
1961	{	1849	{
1962	if (__n > max_size())	1850	// TODO(mpark): Replace with `allocator_traits<allocator>::max_size(*this)`.
		1851	if (__n > (size_t(~0) / sizeof(_Tp)))
1963	__throw_length_error("allocator<const T>::allocate(size_t n)"	1852	__throw_length_error("allocator<const T>::allocate(size_t n)"
1964	" 'n' exceeds maximum supported size");	1853	" 'n' exceeds maximum supported size");
1965	return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));	1854	return static_cast<const _Tp>(_VSTD::__libcpp_allocate(__n sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
1966	}	1855	}
1967	_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT	1856
		1857	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
		1858	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
		1859	const _Tp* allocate(size_t __n, const void*) { return allocate(__n); }
		1860	#endif
		1861
		1862	_LIBCPP_INLINE_VISIBILITY void deallocate(const _Tp* __p, size_t __n)
1968	{_VSTD::__libcpp_deallocate((void) const_cast<_Tp >(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}	1863	{_VSTD::__libcpp_deallocate((void) const_cast<_Tp >(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
1969	_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT	1864
		1865	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
		1866	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
1970	{return size_type(~0) / sizeof(_Tp);}	1867	{return size_type(~0) / sizeof(_Tp);}
		1868
1971	#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)	1869	#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
1972	template <class _Up, class... _Args>	1870	template <class _Up, class... _Args>
1973	_LIBCPP_INLINE_VISIBILITY	1871	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
1974	void	1872	void
1975	construct(_Up* __p, _Args&&... __args)	1873	construct(_Up* __p, _Args&&... __args)
1976	{	1874	{
...	@@ -2029,7 +1927,8 @@ public:	...	@@ -2029,7 +1927,8 @@ public:
2029	::new((void) const_cast<_Tp >(__p)) _Tp(__a0, __a1);	1927	::new((void) const_cast<_Tp >(__p)) _Tp(__a0, __a1);
2030	}	1928	}
2031	#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)	1929	#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
2032	_LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}	1930	_LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
		1931	#endif
2033	};	1932	};
2034		1933
2035	template <class _Tp, class _Up>	1934	template <class _Tp, class _Up>
...	@@ -2134,39 +2033,39 @@ private:	...	@@ -2134,39 +2033,39 @@ private:
2134	public:	2033	public:
2135	typedef _Tp element_type;	2034	typedef _Tp element_type;
2136		2035
2137	_LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {}	2036	_LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {}
2138	_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {}	2037	_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {}
2139	template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) throw()	2038	template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT
2140	: __ptr_(__p.release()) {}	2039	: __ptr_(__p.release()) {}
2141	_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) throw()	2040	_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT
2142	{reset(__p.release()); return *this;}	2041	{reset(__p.release()); return *this;}
2143	template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) throw()	2042	template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT
2144	{reset(__p.release()); return *this;}	2043	{reset(__p.release()); return *this;}
2145	_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) throw()	2044	_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT
2146	{reset(__p.__ptr_); return *this;}	2045	{reset(__p.__ptr_); return *this;}
2147	_LIBCPP_INLINE_VISIBILITY ~auto_ptr() throw() {delete __ptr_;}	2046	_LIBCPP_INLINE_VISIBILITY ~auto_ptr() _NOEXCEPT {delete __ptr_;}
2148		2047
2149	_LIBCPP_INLINE_VISIBILITY _Tp& operator*() const throw()	2048	_LIBCPP_INLINE_VISIBILITY _Tp& operator*() const _NOEXCEPT
2150	{return *__ptr_;}	2049	{return *__ptr_;}
2151	_LIBCPP_INLINE_VISIBILITY _Tp* operator->() const throw() {return __ptr_;}	2050	_LIBCPP_INLINE_VISIBILITY _Tp* operator->() const _NOEXCEPT {return __ptr_;}
2152	_LIBCPP_INLINE_VISIBILITY _Tp* get() const throw() {return __ptr_;}	2051	_LIBCPP_INLINE_VISIBILITY _Tp* get() const _NOEXCEPT {return __ptr_;}
2153	_LIBCPP_INLINE_VISIBILITY _Tp* release() throw()	2052	_LIBCPP_INLINE_VISIBILITY _Tp* release() _NOEXCEPT
2154	{	2053	{
2155	_Tp* __t = __ptr_;	2054	_Tp* __t = __ptr_;
2156	__ptr_ = 0;	2055	__ptr_ = 0;
2157	return __t;	2056	return __t;
2158	}	2057	}
2159	_LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) throw()	2058	_LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) _NOEXCEPT
2160	{	2059	{
2161	if (__ptr_ != __p)	2060	if (__ptr_ != __p)
2162	delete __ptr_;	2061	delete __ptr_;
2163	__ptr_ = __p;	2062	__ptr_ = __p;
2164	}	2063	}
2165		2064
2166	_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {}	2065	_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
2167	template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() throw()	2066	template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT
2168	{auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}	2067	{auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}
2169	template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() throw()	2068	template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() _NOEXCEPT
2170	{return auto_ptr<_Up>(release());}	2069	{return auto_ptr<_Up>(release());}
2171	};	2070	};
2172		2071
...	@@ -3393,6 +3292,8 @@ class _LIBCPP_EXCEPTION_ABI bad_weak_ptr	...	@@ -3393,6 +3292,8 @@ class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
3393	: public std::exception	3292	: public std::exception
3394	{	3293	{
3395	public:	3294	public:
		3295	bad_weak_ptr() _NOEXCEPT = default;
		3296	bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
3396	virtual ~bad_weak_ptr() _NOEXCEPT;	3297	virtual ~bad_weak_ptr() _NOEXCEPT;
3397	virtual const char* what() const _NOEXCEPT;	3298	virtual const char* what() const _NOEXCEPT;
3398	};	3299	};
...	@@ -3628,15 +3529,25 @@ public:	...	@@ -3628,15 +3529,25 @@ public:
3628		3529
3629	template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;	3530	template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
3630		3531
		3532	template<class _Tp, class _Up>
		3533	struct __compatible_with
		3534	#if _LIBCPP_STD_VER > 14
		3535	: is_convertible<remove_extent_t<_Tp>, remove_extent_t<_Up>> {};
		3536	#else
		3537	: is_convertible<_Tp, _Up> {};
		3538	#endif // _LIBCPP_STD_VER > 14
		3539
3631	template<class _Tp>	3540	template<class _Tp>
3632	class _LIBCPP_TEMPLATE_VIS shared_ptr	3541	class _LIBCPP_TEMPLATE_VIS shared_ptr
3633	{	3542	{
3634	public:	3543	public:
3635	typedef _Tp element_type;
3636
3637	#if _LIBCPP_STD_VER > 14	3544	#if _LIBCPP_STD_VER > 14
3638	typedef weak_ptr<_Tp> weak_type;	3545	typedef weak_ptr<_Tp> weak_type;
		3546	typedef remove_extent_t<_Tp> element_type;
		3547	#else
		3548	typedef _Tp element_type;
3639	#endif	3549	#endif
		3550
3640	private:	3551	private:
3641	element_type* __ptr_;	3552	element_type* __ptr_;
3642	__shared_weak_count* __cntrl_;	3553	__shared_weak_count* __cntrl_;
...	@@ -3649,13 +3560,13 @@ public:	...	@@ -3649,13 +3560,13 @@ public:
3649	_LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT;	3560	_LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT;
3650	template<class _Yp>	3561	template<class _Yp>
3651	explicit shared_ptr(_Yp* __p,	3562	explicit shared_ptr(_Yp* __p,
3652	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());	3563	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat());
3653	template<class _Yp, class _Dp>	3564	template<class _Yp, class _Dp>
3654	shared_ptr(_Yp* __p, _Dp __d,	3565	shared_ptr(_Yp* __p, _Dp __d,
3655	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());	3566	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat());
3656	template<class _Yp, class _Dp, class _Alloc>	3567	template<class _Yp, class _Dp, class _Alloc>
3657	shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,	3568	shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
3658	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());	3569	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat());
3659	template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);	3570	template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
3660	template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);	3571	template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
3661	template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT;	3572	template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT;
...	@@ -3664,13 +3575,13 @@ public:	...	@@ -3664,13 +3575,13 @@ public:
3664	template<class _Yp>	3575	template<class _Yp>
3665	_LIBCPP_INLINE_VISIBILITY	3576	_LIBCPP_INLINE_VISIBILITY
3666	shared_ptr(const shared_ptr<_Yp>& __r,	3577	shared_ptr(const shared_ptr<_Yp>& __r,
3667	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat())	3578	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
3668	_NOEXCEPT;	3579	_NOEXCEPT;
3669	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES	3580	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
3670	_LIBCPP_INLINE_VISIBILITY	3581	_LIBCPP_INLINE_VISIBILITY
3671	shared_ptr(shared_ptr&& __r) _NOEXCEPT;	3582	shared_ptr(shared_ptr&& __r) _NOEXCEPT;
3672	template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(shared_ptr<_Yp>&& __r,	3583	template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(shared_ptr<_Yp>&& __r,
3673	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat())	3584	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
3674	_NOEXCEPT;	3585	_NOEXCEPT;
3675	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES	3586	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
3676	template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,	3587	template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
...	@@ -3686,7 +3597,6 @@ public:	...	@@ -3686,7 +3597,6 @@ public:
3686	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());	3597	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());
3687	#endif	3598	#endif
3688	#endif	3599	#endif
3689	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
3690	template <class _Yp, class _Dp>	3600	template <class _Yp, class _Dp>
3691	shared_ptr(unique_ptr<_Yp, _Dp>&&,	3601	shared_ptr(unique_ptr<_Yp, _Dp>&&,
3692	typename enable_if	3602	typename enable_if
...	@@ -3705,26 +3615,6 @@ public:	...	@@ -3705,26 +3615,6 @@ public:
3705	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,	3615	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
3706	__nat	3616	__nat
3707	>::type = __nat());	3617	>::type = __nat());
3708	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
3709	template <class _Yp, class _Dp>
3710	shared_ptr(unique_ptr<_Yp, _Dp>,
3711	typename enable_if
3712	<
3713	!is_lvalue_reference<_Dp>::value &&
3714	!is_array<_Yp>::value &&
3715	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
3716	__nat
3717	>::type = __nat());
3718	template <class _Yp, class _Dp>
3719	shared_ptr(unique_ptr<_Yp, _Dp>,
3720	typename enable_if
3721	<
3722	is_lvalue_reference<_Dp>::value &&
3723	!is_array<_Yp>::value &&
3724	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
3725	__nat
3726	>::type = __nat());
3727	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
3728		3618
3729	~shared_ptr();	3619	~shared_ptr();
3730		3620
...	@@ -3733,7 +3623,7 @@ public:	...	@@ -3733,7 +3623,7 @@ public:
3733	template<class _Yp>	3623	template<class _Yp>
3734	typename enable_if	3624	typename enable_if
3735	<	3625	<
3736	is_convertible<_Yp, element_type>::value,	3626	__compatible_with<_Yp, element_type>::value,
3737	shared_ptr&	3627	shared_ptr&
3738	>::type	3628	>::type
3739	_LIBCPP_INLINE_VISIBILITY	3629	_LIBCPP_INLINE_VISIBILITY
...	@@ -3744,8 +3634,8 @@ public:	...	@@ -3744,8 +3634,8 @@ public:
3744	template<class _Yp>	3634	template<class _Yp>
3745	typename enable_if	3635	typename enable_if
3746	<	3636	<
3747	is_convertible<_Yp, element_type>::value,	3637	__compatible_with<_Yp, element_type>::value,
3748	shared_ptr<_Tp>&	3638	shared_ptr&
3749	>::type	3639	>::type
3750	_LIBCPP_INLINE_VISIBILITY	3640	_LIBCPP_INLINE_VISIBILITY
3751	operator=(shared_ptr<_Yp>&& __r);	3641	operator=(shared_ptr<_Yp>&& __r);
...	@@ -3795,7 +3685,7 @@ public:	...	@@ -3795,7 +3685,7 @@ public:
3795	template<class _Yp>	3685	template<class _Yp>
3796	typename enable_if	3686	typename enable_if
3797	<	3687	<
3798	is_convertible<_Yp, element_type>::value,	3688	__compatible_with<_Yp, element_type>::value,
3799	void	3689	void
3800	>::type	3690	>::type
3801	_LIBCPP_INLINE_VISIBILITY	3691	_LIBCPP_INLINE_VISIBILITY
...	@@ -3803,7 +3693,7 @@ public:	...	@@ -3803,7 +3693,7 @@ public:
3803	template<class _Yp, class _Dp>	3693	template<class _Yp, class _Dp>
3804	typename enable_if	3694	typename enable_if
3805	<	3695	<
3806	is_convertible<_Yp, element_type>::value,	3696	__compatible_with<_Yp, element_type>::value,
3807	void	3697	void
3808	>::type	3698	>::type
3809	_LIBCPP_INLINE_VISIBILITY	3699	_LIBCPP_INLINE_VISIBILITY
...	@@ -3811,7 +3701,7 @@ public:	...	@@ -3811,7 +3701,7 @@ public:
3811	template<class _Yp, class _Dp, class _Alloc>	3701	template<class _Yp, class _Dp, class _Alloc>
3812	typename enable_if	3702	typename enable_if
3813	<	3703	<
3814	is_convertible<_Yp, element_type>::value,	3704	__compatible_with<_Yp, element_type>::value,
3815	void	3705	void
3816	>::type	3706	>::type
3817	_LIBCPP_INLINE_VISIBILITY	3707	_LIBCPP_INLINE_VISIBILITY
...	@@ -3823,7 +3713,12 @@ public:	...	@@ -3823,7 +3713,12 @@ public:
3823	typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT	3713	typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT
3824	{return *__ptr_;}	3714	{return *__ptr_;}
3825	_LIBCPP_INLINE_VISIBILITY	3715	_LIBCPP_INLINE_VISIBILITY
3826	element_type* operator->() const _NOEXCEPT {return __ptr_;}	3716	element_type* operator->() const _NOEXCEPT
		3717	{
		3718	static_assert(!_VSTD::is_array<_Tp>::value,
		3719	"std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
		3720	return __ptr_;
		3721	}
3827	_LIBCPP_INLINE_VISIBILITY	3722	_LIBCPP_INLINE_VISIBILITY
3828	long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;}	3723	long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;}
3829	_LIBCPP_INLINE_VISIBILITY	3724	_LIBCPP_INLINE_VISIBILITY
...	@@ -3843,6 +3738,17 @@ public:	...	@@ -3843,6 +3738,17 @@ public:
3843	__owner_equivalent(const shared_ptr& __p) const	3738	__owner_equivalent(const shared_ptr& __p) const
3844	{return __cntrl_ == __p.__cntrl_;}	3739	{return __cntrl_ == __p.__cntrl_;}
3845		3740
		3741	#if _LIBCPP_STD_VER > 14
		3742	typename add_lvalue_reference<element_type>::type
		3743	_LIBCPP_INLINE_VISIBILITY
		3744	operator[](ptrdiff_t __i) const
		3745	{
		3746	static_assert(_VSTD::is_array<_Tp>::value,
		3747	"std::shared_ptr<T>::operator[] is only valid when T is an array type.");
		3748	return __ptr_[__i];
		3749	}
		3750	#endif
		3751
3846	#ifndef _LIBCPP_NO_RTTI	3752	#ifndef _LIBCPP_NO_RTTI
3847	template <class _Dp>	3753	template <class _Dp>
3848	_LIBCPP_INLINE_VISIBILITY	3754	_LIBCPP_INLINE_VISIBILITY
...	@@ -3854,7 +3760,7 @@ public:	...	@@ -3854,7 +3760,7 @@ public:
3854		3760
3855	template<class _Yp, class _CntrlBlk>	3761	template<class _Yp, class _CntrlBlk>
3856	static shared_ptr<_Tp>	3762	static shared_ptr<_Tp>
3857	__create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl)	3763	__create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl) _NOEXCEPT
3858	{	3764	{
3859	shared_ptr<_Tp> __r;	3765	shared_ptr<_Tp> __r;
3860	__r.__ptr_ = __p;	3766	__r.__ptr_ = __p;
...	@@ -3863,11 +3769,6 @@ public:	...	@@ -3863,11 +3769,6 @@ public:
3863	return __r;	3769	return __r;
3864	}	3770	}
3865		3771
3866	template<class _Alloc, class ..._Args>
3867	static
3868	shared_ptr<_Tp>
3869	allocate_shared(const _Alloc& __a, _Args&& ...__args);
3870
3871	private:	3772	private:
3872	template <class _Yp, bool = is_function<_Yp>::value>	3773	template <class _Yp, bool = is_function<_Yp>::value>
3873	struct __shared_ptr_default_allocator	3774	struct __shared_ptr_default_allocator
...	@@ -3900,10 +3801,28 @@ private:	...	@@ -3900,10 +3801,28 @@ private:
3900		3801
3901	_LIBCPP_INLINE_VISIBILITY void __enable_weak_this(...) _NOEXCEPT {}	3802	_LIBCPP_INLINE_VISIBILITY void __enable_weak_this(...) _NOEXCEPT {}
3902		3803
		3804	template <class, class _Yp>
		3805	struct __shared_ptr_default_delete
		3806	: default_delete<_Yp> {};
		3807
		3808	template <class _Yp, class _Un, size_t _Sz>
		3809	struct __shared_ptr_default_delete<_Yp[_Sz], _Un>
		3810	: default_delete<_Yp[]> {};
		3811
		3812	template <class _Yp, class _Un>
		3813	struct __shared_ptr_default_delete<_Yp[], _Un>
		3814	: default_delete<_Yp[]> {};
		3815
3903	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;	3816	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
3904	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;	3817	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
3905	};	3818	};
3906		3819
		3820	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
		3821	template<class _Tp>
		3822	shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
		3823	template<class _Tp, class _Dp>
		3824	shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
		3825	#endif
3907		3826
3908	template<class _Tp>	3827	template<class _Tp>
3909	inline	3828	inline
...	@@ -3926,13 +3845,13 @@ shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT	...	@@ -3926,13 +3845,13 @@ shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT
3926	template<class _Tp>	3845	template<class _Tp>
3927	template<class _Yp>	3846	template<class _Yp>
3928	shared_ptr<_Tp>::shared_ptr(_Yp* __p,	3847	shared_ptr<_Tp>::shared_ptr(_Yp* __p,
3929	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)	3848	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
3930	: __ptr_(__p)	3849	: __ptr_(__p)
3931	{	3850	{
3932	unique_ptr<_Yp> __hold(__p);	3851	unique_ptr<_Yp> __hold(__p);
3933	typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;	3852	typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
3934	typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, _AllocT > _CntrlBlk;	3853	typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT > _CntrlBlk;
3935	__cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), _AllocT());	3854	__cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
3936	__hold.release();	3855	__hold.release();
3937	__enable_weak_this(__p, __p);	3856	__enable_weak_this(__p, __p);
3938	}	3857	}
...	@@ -3940,7 +3859,7 @@ shared_ptr<_Tp>::shared_ptr(_Yp* __p,	...	@@ -3940,7 +3859,7 @@ shared_ptr<_Tp>::shared_ptr(_Yp* __p,
3940	template<class _Tp>	3859	template<class _Tp>
3941	template<class _Yp, class _Dp>	3860	template<class _Yp, class _Dp>
3942	shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,	3861	shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
3943	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)	3862	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
3944	: __ptr_(__p)	3863	: __ptr_(__p)
3945	{	3864	{
3946	#ifndef _LIBCPP_NO_EXCEPTIONS	3865	#ifndef _LIBCPP_NO_EXCEPTIONS
...	@@ -3986,7 +3905,7 @@ shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)	...	@@ -3986,7 +3905,7 @@ shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)
3986	template<class _Tp>	3905	template<class _Tp>
3987	template<class _Yp, class _Dp, class _Alloc>	3906	template<class _Yp, class _Dp, class _Alloc>
3988	shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,	3907	shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
3989	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)	3908	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
3990	: __ptr_(__p)	3909	: __ptr_(__p)
3991	{	3910	{
3992	#ifndef _LIBCPP_NO_EXCEPTIONS	3911	#ifndef _LIBCPP_NO_EXCEPTIONS
...	@@ -4064,7 +3983,7 @@ template<class _Tp>	...	@@ -4064,7 +3983,7 @@ template<class _Tp>
4064	template<class _Yp>	3983	template<class _Yp>
4065	inline	3984	inline
4066	shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,	3985	shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
4067	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)	3986	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
4068	_NOEXCEPT	3987	_NOEXCEPT
4069	: __ptr_(__r.__ptr_),	3988	: __ptr_(__r.__ptr_),
4070	__cntrl_(__r.__cntrl_)	3989	__cntrl_(__r.__cntrl_)
...	@@ -4089,7 +4008,7 @@ template<class _Tp>	...	@@ -4089,7 +4008,7 @@ template<class _Tp>
4089	template<class _Yp>	4008	template<class _Yp>
4090	inline	4009	inline
4091	shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,	4010	shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
4092	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)	4011	typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
4093	_NOEXCEPT	4012	_NOEXCEPT
4094	: __ptr_(__r.__ptr_),	4013	: __ptr_(__r.__ptr_),
4095	__cntrl_(__r.__cntrl_)	4014	__cntrl_(__r.__cntrl_)
...	@@ -4120,11 +4039,7 @@ shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r,	...	@@ -4120,11 +4039,7 @@ shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r,
4120		4039
4121	template<class _Tp>	4040	template<class _Tp>
4122	template <class _Yp, class _Dp>	4041	template <class _Yp, class _Dp>
4123	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
4124	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,	4042	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
4125	#else
4126	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
4127	#endif
4128	typename enable_if	4043	typename enable_if
4129	<	4044	<
4130	!is_lvalue_reference<_Dp>::value &&	4045	!is_lvalue_reference<_Dp>::value &&
...	@@ -4150,11 +4065,7 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,	...	@@ -4150,11 +4065,7 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
4150		4065
4151	template<class _Tp>	4066	template<class _Tp>
4152	template <class _Yp, class _Dp>	4067	template <class _Yp, class _Dp>
4153	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
4154	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,	4068	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
4155	#else
4156	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
4157	#endif
4158	typename enable_if	4069	typename enable_if
4159	<	4070	<
4160	is_lvalue_reference<_Dp>::value &&	4071	is_lvalue_reference<_Dp>::value &&
...	@@ -4174,32 +4085,12 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,	...	@@ -4174,32 +4085,12 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
4174	typedef __shared_ptr_pointer<_Yp*,	4085	typedef __shared_ptr_pointer<_Yp*,
4175	reference_wrapper<typename remove_reference<_Dp>::type>,	4086	reference_wrapper<typename remove_reference<_Dp>::type>,
4176	_AllocT > _CntrlBlk;	4087	_AllocT > _CntrlBlk;
4177	__cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), _AllocT());	4088	__cntrl_ = new _CntrlBlk(__r.get(), _VSTD::ref(__r.get_deleter()), _AllocT());
4178	__enable_weak_this(__r.get(), __r.get());	4089	__enable_weak_this(__r.get(), __r.get());
4179	}	4090	}
4180	__r.release();	4091	__r.release();
4181	}	4092	}
4182		4093
4183	template<class _Tp>
4184	template<class _Alloc, class ..._Args>
4185	shared_ptr<_Tp>
4186	shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
4187	{
4188	static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in allocate_shared" );
4189	typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
4190	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
4191	typedef __allocator_destructor<_A2> _D2;
4192	_A2 __a2(__a);
4193	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
4194	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
4195	_CntrlBlk(__a, _VSTD::forward<_Args>(__args)...);
4196	shared_ptr<_Tp> __r;
4197	__r.__ptr_ = __hold2.get()->get();
4198	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
4199	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4200	return __r;
4201	}
4202
4203	template<class _Tp>	4094	template<class _Tp>
4204	shared_ptr<_Tp>::~shared_ptr()	4095	shared_ptr<_Tp>::~shared_ptr()
4205	{	4096	{
...	@@ -4221,7 +4112,7 @@ template<class _Yp>	...	@@ -4221,7 +4112,7 @@ template<class _Yp>
4221	inline	4112	inline
4222	typename enable_if	4113	typename enable_if
4223	<	4114	<
4224	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,	4115	__compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
4225	shared_ptr<_Tp>&	4116	shared_ptr<_Tp>&
4226	>::type	4117	>::type
4227	shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT	4118	shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT
...	@@ -4246,7 +4137,7 @@ template<class _Yp>	...	@@ -4246,7 +4137,7 @@ template<class _Yp>
4246	inline	4137	inline
4247	typename enable_if	4138	typename enable_if
4248	<	4139	<
4249	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,	4140	__compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
4250	shared_ptr<_Tp>&	4141	shared_ptr<_Tp>&
4251	>::type	4142	>::type
4252	shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)	4143	shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
...	@@ -4347,7 +4238,7 @@ template<class _Yp>	...	@@ -4347,7 +4238,7 @@ template<class _Yp>
4347	inline	4238	inline
4348	typename enable_if	4239	typename enable_if
4349	<	4240	<
4350	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,	4241	__compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
4351	void	4242	void
4352	>::type	4243	>::type
4353	shared_ptr<_Tp>::reset(_Yp* __p)	4244	shared_ptr<_Tp>::reset(_Yp* __p)
...	@@ -4360,7 +4251,7 @@ template<class _Yp, class _Dp>	...	@@ -4360,7 +4251,7 @@ template<class _Yp, class _Dp>
4360	inline	4251	inline
4361	typename enable_if	4252	typename enable_if
4362	<	4253	<
4363	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,	4254	__compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
4364	void	4255	void
4365	>::type	4256	>::type
4366	shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)	4257	shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
...	@@ -4373,7 +4264,7 @@ template<class _Yp, class _Dp, class _Alloc>	...	@@ -4373,7 +4264,7 @@ template<class _Yp, class _Dp, class _Alloc>
4373	inline	4264	inline
4374	typename enable_if	4265	typename enable_if
4375	<	4266	<
4376	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,	4267	__compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
4377	void	4268	void
4378	>::type	4269	>::type
4379	shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)	4270	shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
...	@@ -4412,7 +4303,19 @@ typename enable_if	...	@@ -4412,7 +4303,19 @@ typename enable_if
4412	>::type	4303	>::type
4413	allocate_shared(const _Alloc& __a, _Args&& ...__args)	4304	allocate_shared(const _Alloc& __a, _Args&& ...__args)
4414	{	4305	{
4415	return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...);	4306	static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in allocate_shared");
		4307
		4308	typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
		4309	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
		4310	typedef __allocator_destructor<_A2> _D2;
		4311
		4312	_A2 __a2(__a);
		4313	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
		4314	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
		4315	_CntrlBlk(__a, _VSTD::forward<_Args>(__args)...);
		4316
		4317	typename shared_ptr<_Tp>::element_type *__p = __hold2.get()->get();
		4318	return shared_ptr<_Tp>::__create_with_control_block(__p, _VSTD::addressof(*__hold2.release()));
4416	}	4319	}
4417		4320
4418	template<class _Tp, class _Up>	4321	template<class _Tp, class _Up>
...	@@ -4575,41 +4478,41 @@ swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT	...	@@ -4575,41 +4478,41 @@ swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT
4575		4478
4576	template<class _Tp, class _Up>	4479	template<class _Tp, class _Up>
4577	inline _LIBCPP_INLINE_VISIBILITY	4480	inline _LIBCPP_INLINE_VISIBILITY
4578	typename enable_if	4481	shared_ptr<_Tp>
4579	<
4580	!is_array<_Tp>::value && !is_array<_Up>::value,
4581	shared_ptr<_Tp>
4582	>::type
4583	static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT	4482	static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
4584	{	4483	{
4585	return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get()));	4484	return shared_ptr<_Tp>(__r,
		4485	static_cast<
		4486	typename shared_ptr<_Tp>::element_type*>(__r.get()));
4586	}	4487	}
4587		4488
4588	template<class _Tp, class _Up>	4489	template<class _Tp, class _Up>
4589	inline _LIBCPP_INLINE_VISIBILITY	4490	inline _LIBCPP_INLINE_VISIBILITY
4590	typename enable_if	4491	shared_ptr<_Tp>
4591	<
4592	!is_array<_Tp>::value && !is_array<_Up>::value,
4593	shared_ptr<_Tp>
4594	>::type
4595	dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT	4492	dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
4596	{	4493	{
4597	_Tp* __p = dynamic_cast<_Tp*>(__r.get());	4494	typedef typename shared_ptr<_Tp>::element_type _ET;
		4495	_ET* __p = dynamic_cast<_ET*>(__r.get());
4598	return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();	4496	return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
4599	}	4497	}
4600		4498
4601	template<class _Tp, class _Up>	4499	template<class _Tp, class _Up>
4602	typename enable_if	4500	shared_ptr<_Tp>
4603	<
4604	is_array<_Tp>::value == is_array<_Up>::value,
4605	shared_ptr<_Tp>
4606	>::type
4607	const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT	4501	const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
4608	{	4502	{
4609	typedef typename remove_extent<_Tp>::type _RTp;	4503	typedef typename shared_ptr<_Tp>::element_type _RTp;
4610	return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));	4504	return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
4611	}	4505	}
4612		4506
		4507	template<class _Tp, class _Up>
		4508	shared_ptr<_Tp>
		4509	reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
		4510	{
		4511	return shared_ptr<_Tp>(__r,
		4512	reinterpret_cast<
		4513	typename shared_ptr<_Tp>::element_type*>(__r.get()));
		4514	}
		4515
4613	#ifndef _LIBCPP_NO_RTTI	4516	#ifndef _LIBCPP_NO_RTTI
4614		4517
4615	template<class _Dp, class _Tp>	4518	template<class _Dp, class _Tp>
...	@@ -4712,6 +4615,11 @@ public:	...	@@ -4712,6 +4615,11 @@ public:
4712	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;	4615	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
4713	};	4616	};
4714		4617
		4618	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
		4619	template<class _Tp>
		4620	weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
		4621	#endif
		4622
4715	template<class _Tp>	4623	template<class _Tp>
4716	inline	4624	inline
4717	_LIBCPP_CONSTEXPR	4625	_LIBCPP_CONSTEXPR
...	@@ -5008,7 +4916,7 @@ struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> >	...	@@ -5008,7 +4916,7 @@ struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> >
5008	_LIBCPP_INLINE_VISIBILITY	4916	_LIBCPP_INLINE_VISIBILITY
5009	result_type operator()(const argument_type& __ptr) const _NOEXCEPT	4917	result_type operator()(const argument_type& __ptr) const _NOEXCEPT
5010	{	4918	{
5011	return hash<_Tp*>()(__ptr.get());	4919	return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get());
5012	}	4920	}
5013	};	4921	};
5014		4922

lib/libcxx/include/module.modulemap+23

 @@ -231,6 +231,11 @@ module std [system] {
     header "atomic"
     export *
   }
+  module barrier {
+    requires cplusplus14
+    header "barrier"
+    export *
+  }
   module bit {
     header "bit"
     export *
 @@ -262,6 +267,10 @@ module std [system] {
     header "complex"
     export *
   }
+  module concepts {
+    header "concepts"
+    export *
+  }
   module condition_variable {
     header "condition_variable"
     export *
 @@ -334,6 +343,11 @@ module std [system] {
     header "iterator"
     export *
   }
+  module latch {
+    requires cplusplus14
+    header "latch"
+    export *
+  }
   module limits {
     header "limits"
     export *
 @@ -364,6 +378,10 @@ module std [system] {
     header "new"
     export *
   }
+  module numbers {
+    header "numbers"
+    export *
+  }
   module numeric {
     header "numeric"
     export *
 @@ -400,6 +418,11 @@ module std [system] {
     header "scoped_allocator"
     export *
   }
+  module semaphore {
+    requires cplusplus14
+    header "semaphore"
+    export *
+  }
   module set {
     header "set"
     export initializer_list

lib/libcxx/include/numbers created+141

...	@@ -0,0 +1,141 @@
1	// -- C++ --
2	//===---------------------------- numbers ---------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP_NUMBERS
11	#define _LIBCPP_NUMBERS
12
13	/*
14	numbers synopsis
15
16	namespace std::numbers {
17	template<class T> inline constexpr T e_v = unspecified;
18	template<class T> inline constexpr T log2e_v = unspecified;
19	template<class T> inline constexpr T log10e_v = unspecified;
20	template<class T> inline constexpr T pi_v = unspecified;
21	template<class T> inline constexpr T inv_pi_v = unspecified;
22	template<class T> inline constexpr T inv_sqrtpi_v = unspecified;
23	template<class T> inline constexpr T ln2_v = unspecified;
24	template<class T> inline constexpr T ln10_v = unspecified;
25	template<class T> inline constexpr T sqrt2_v = unspecified;
26	template<class T> inline constexpr T sqrt3_v = unspecified;
27	template<class T> inline constexpr T inv_sqrt3_v = unspecified;
28	template<class T> inline constexpr T egamma_v = unspecified;
29	template<class T> inline constexpr T phi_v = unspecified;
30
31	template<floating_point T> inline constexpr T e_v<T> = see below;
32	template<floating_point T> inline constexpr T log2e_v<T> = see below;
33	template<floating_point T> inline constexpr T log10e_v<T> = see below;
34	template<floating_point T> inline constexpr T pi_v<T> = see below;
35	template<floating_point T> inline constexpr T inv_pi_v<T> = see below;
36	template<floating_point T> inline constexpr T inv_sqrtpi_v<T> = see below;
37	template<floating_point T> inline constexpr T ln2_v<T> = see below;
38	template<floating_point T> inline constexpr T ln10_v<T> = see below;
39	template<floating_point T> inline constexpr T sqrt2_v<T> = see below;
40	template<floating_point T> inline constexpr T sqrt3_v<T> = see below;
41	template<floating_point T> inline constexpr T inv_sqrt3_v<T> = see below;
42	template<floating_point T> inline constexpr T egamma_v<T> = see below;
43	template<floating_point T> inline constexpr T phi_v<T> = see below;
44
45	inline constexpr double e = e_v<double>;
46	inline constexpr double log2e = log2e_v<double>;
47	inline constexpr double log10e = log10e_v<double>;
48	inline constexpr double pi = pi_v<double>;
49	inline constexpr double inv_pi = inv_pi_v<double>;
50	inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
51	inline constexpr double ln2 = ln2_v<double>;
52	inline constexpr double ln10 = ln10_v<double>;
53	inline constexpr double sqrt2 = sqrt2_v<double>;
54	inline constexpr double sqrt3 = sqrt3_v<double>;
55	inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
56	inline constexpr double egamma = egamma_v<double>;
57	inline constexpr double phi = phi_v<double>;
58	}
59	*/
60
61	#include <__config>
62
63	#if _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
64
65	#include <type_traits>
66	#include <version>
67
68	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
69	#pragma GCC system_header
70	#endif
71
72	_LIBCPP_PUSH_MACROS
73	#include <__undef_macros>
74
75	_LIBCPP_BEGIN_NAMESPACE_STD
76
77	namespace numbers {
78
79	template <class T>
80	inline constexpr bool __false = false;
81
82	template <class T>
83	struct __illformed
84	{
85	static_assert(__false<T>, "A program that instantiates a primary template of a mathematical constant variable template is ill-formed.");
86	};
87
88	template <class T> inline constexpr T e_v = __illformed<T>{};
89	template <class T> inline constexpr T log2e_v = __illformed<T>{};
90	template <class T> inline constexpr T log10e_v = __illformed<T>{};
91	template <class T> inline constexpr T pi_v = __illformed<T>{};
92	template <class T> inline constexpr T inv_pi_v = __illformed<T>{};
93	template <class T> inline constexpr T inv_sqrtpi_v = __illformed<T>{};
94	template <class T> inline constexpr T ln2_v = __illformed<T>{};
95	template <class T> inline constexpr T ln10_v = __illformed<T>{};
96	template <class T> inline constexpr T sqrt2_v = __illformed<T>{};
97	template <class T> inline constexpr T sqrt3_v = __illformed<T>{};
98	template <class T> inline constexpr T inv_sqrt3_v = __illformed<T>{};
99	template <class T> inline constexpr T egamma_v = __illformed<T>{};
100	template <class T> inline constexpr T phi_v = __illformed<T>{};
101
102	template <class T>
103	concept __floating_point = std::is_floating_point_v<T>;
104
105	template <__floating_point T> inline constexpr T e_v<T> = 2.718281828459045235360287471352662;
106	template <__floating_point T> inline constexpr T log2e_v<T> = 1.442695040888963407359924681001892;
107	template <__floating_point T> inline constexpr T log10e_v<T> = 0.434294481903251827651128918916605;
108	template <__floating_point T> inline constexpr T pi_v<T> = 3.141592653589793238462643383279502;
109	template <__floating_point T> inline constexpr T inv_pi_v<T> = 0.318309886183790671537767526745028;
110	template <__floating_point T> inline constexpr T inv_sqrtpi_v<T> = 0.564189583547756286948079451560772;
111	template <__floating_point T> inline constexpr T ln2_v<T> = 0.693147180559945309417232121458176;
112	template <__floating_point T> inline constexpr T ln10_v<T> = 2.302585092994045684017991454684364;
113	template <__floating_point T> inline constexpr T sqrt2_v<T> = 1.414213562373095048801688724209698;
114	template <__floating_point T> inline constexpr T sqrt3_v<T> = 1.732050807568877293527446341505872;
115	template <__floating_point T> inline constexpr T inv_sqrt3_v<T> = 0.577350269189625764509148780501957;
116	template <__floating_point T> inline constexpr T egamma_v<T> = 0.577215664901532860606512090082402;
117	template <__floating_point T> inline constexpr T phi_v<T> = 1.618033988749894848204586834365638;
118
119	inline constexpr double e = e_v<double>;
120	inline constexpr double log2e = log2e_v<double>;
121	inline constexpr double log10e = log10e_v<double>;
122	inline constexpr double pi = pi_v<double>;
123	inline constexpr double inv_pi = inv_pi_v<double>;
124	inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
125	inline constexpr double ln2 = ln2_v<double>;
126	inline constexpr double ln10 = ln10_v<double>;
127	inline constexpr double sqrt2 = sqrt2_v<double>;
128	inline constexpr double sqrt3 = sqrt3_v<double>;
129	inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
130	inline constexpr double egamma = egamma_v<double>;
131	inline constexpr double phi = phi_v<double>;
132
133	} // namespace numbers
134
135	_LIBCPP_END_NAMESPACE_STD
136
137	_LIBCPP_POP_MACROS
138
139	#endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
140
141	#endif // _LIBCPP_NUMBERS

lib/libcxx/include/ostream+3-3

lib/libcxx/include/random+5

 @@ -4048,10 +4048,12 @@ binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
     result_type __rd = __ru;
     while (true)
     {
+        bool __break = true;
         if (__rd >= 1)
         {
             __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1));
             __u -= __pd;
+            __break = false;
             if (__u < 0)
                 return __rd - 1;
         }
 @@ -4062,9 +4064,12 @@ binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
         {
             __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru;
             __u -= __pu;
+            __break = false;
             if (__u < 0)
                 return __ru;
         }
+        if (__break)
+            return 0;
     }
 }

lib/libcxx/include/regex+47-21

 @@ -21,7 +21,7 @@ namespace std
 namespace regex_constants
 {
-emum syntax_option_type
+enum syntax_option_type
 {
     icase      = unspecified,
     nosubs     = unspecified,
 @@ -631,7 +631,7 @@ template <class OutputIterator, class BidirectionalIterator,
                   const basic_regex<charT, traits>& e, const charT* fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
-template <class traits, class charT, class ST, class SA, class FST, class FSA>>
+template <class traits, class charT, class ST, class SA, class FST, class FSA>
     basic_string<charT, ST, SA>
     regex_replace(const basic_string<charT, ST, SA>& s,
                   const basic_regex<charT, traits>& e,
 @@ -675,9 +675,9 @@ public:
     regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
                    const regex_type& re,
                    regex_constants::match_flag_type m = regex_constants::match_default);
-    regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
+    regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
-                   const regex_type&& __re,
+                   const regex_type&& re,
-                   regex_constants::match_flag_type __m
+                   regex_constants::match_flag_type m
                                      = regex_constants::match_default) = delete; // C++14
     regex_iterator(const regex_iterator&);
     regex_iterator& operator=(const regex_iterator&);
 @@ -698,7 +698,7 @@ typedef regex_iterator<string::const_iterator>  sregex_iterator;
 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
 template <class BidirectionalIterator,
-          class charT = typename iterator_traits< BidirectionalIterator>::value_type,
+          class charT = typename iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT>>
 class regex_token_iterator
 {
 @@ -735,8 +735,8 @@ public:
                              regex_constants::match_flag_type m = regex_constants::match_default);
     template <size_t N>
         regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
-                             const regex_type& re, const int (&submatches)[N],
+                             const regex_type&& re, const int (&submatches)[N],
-                             regex_constants::match_flag_type m = regex_constants::match_default) = delete // C++14;
+                             regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
     regex_token_iterator(const regex_token_iterator&);
     regex_token_iterator& operator=(const regex_token_iterator&);
 @@ -977,7 +977,8 @@ class _LIBCPP_EXCEPTION_ABI regex_error
     regex_constants::error_type __code_;
 public:
     explicit regex_error(regex_constants::error_type __ecode);
-    virtual ~regex_error() throw();
+    regex_error(const regex_error&) _NOEXCEPT = default;
+    virtual ~regex_error() _NOEXCEPT;
      _LIBCPP_INLINE_VISIBILITY
     regex_constants::error_type code() const {return __code_;}
 };
 @@ -1000,7 +1001,19 @@ public:
     typedef _CharT                  char_type;
     typedef basic_string<char_type> string_type;
     typedef locale                  locale_type;
+#ifdef __BIONIC__
+    // Originally bionic's ctype_base used its own ctype masks because the
+    // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask
+    // was only 8 bits wide and already saturated, so it used a wider type here
+    // to make room for __regex_word (then a part of this class rather than
+    // ctype_base). Bionic has since moved to the builtin ctype_base
+    // implementation, but this was not updated to match. Since then Android has
+    // needed to maintain a stable libc++ ABI, and this can't be changed without
+    // an ABI break.
+    typedef uint16_t char_class_type;
+#else
     typedef ctype_base::mask        char_class_type;
+#endif
     static const char_class_type __regex_word = ctype_base::__regex_word;
 private:
 @@ -2837,6 +2850,8 @@ private:
         __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
                           basic_string<_CharT>* __str = nullptr);
+    bool __test_back_ref(_CharT c);
     _LIBCPP_INLINE_VISIBILITY
     void __push_l_anchor();
     void __push_r_anchor();
 @@ -3408,18 +3423,8 @@ basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
+        if (__temp != __last && *__first == '\\' && __test_back_ref(*__temp))
-        {
+            __first = ++__temp;
-            if (*__first == '\\')
-            {
-                int __val = __traits_.value(*__temp, 10);
-                if (__val >= 1 && __val <= 9)
-                {
-                    __push_back_ref(__val);
-                    __first = ++__temp;
-                }
-            }
-        }
     }
     return __first;
 }
 @@ -3547,6 +3552,8 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
                 default:
                     if (__get_grammar(__flags_) == awk)
                         __first = __parse_awk_escape(++__first, __last);
+                    else if(__test_back_ref(*__temp))
+                        __first = ++__temp;
                     break;
                 }
             }
 @@ -4660,6 +4667,22 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
     return __first;
 }
+template <class _CharT, class _Traits>
+bool
+basic_regex<_CharT, _Traits>::__test_back_ref(_CharT c)
+{
+    unsigned __val = __traits_.value(c, 10);
+    if (__val >= 1 && __val <= 9)
+    {
+        if (__val > mark_count())
+            __throw_regex_error<regex_constants::error_backref>();
+        __push_back_ref(__val);
+        return true;
+    }
+    return false;
+}
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max,
 @@ -5917,6 +5940,9 @@ basic_regex<_CharT, _Traits>::__search(
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags) const
 {
+    if (__flags & regex_constants::match_prev_avail)
+        __flags &= ~(regex_constants::match_not_bol | regex_constants::match_not_bow);
     __m.__init(1 + mark_count(), __first, __last,
                                     __flags & regex_constants::__no_update_pos);
     if (__match_at_start(__first, __last, __m, __flags,

lib/libcxx/include/semaphore created+235

...	@@ -0,0 +1,235 @@
1	// -- C++ --
2	//===--------------------------- semaphore --------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP_SEMAPHORE
11	#define _LIBCPP_SEMAPHORE
12
13	/*
14	semaphore synopsis
15
16	namespace std {
17
18	template<ptrdiff_t least_max_value = implementation-defined>
19	class counting_semaphore
20	{
21	public:
22	static constexpr ptrdiff_t max() noexcept;
23
24	constexpr explicit counting_semaphore(ptrdiff_t desired);
25	~counting_semaphore();
26
27	counting_semaphore(const counting_semaphore&) = delete;
28	counting_semaphore& operator=(const counting_semaphore&) = delete;
29
30	void release(ptrdiff_t update = 1);
31	void acquire();
32	bool try_acquire() noexcept;
33	template<class Rep, class Period>
34	bool try_acquire_for(const chrono::duration<Rep, Period>& rel_time);
35	template<class Clock, class Duration>
36	bool try_acquire_until(const chrono::time_point<Clock, Duration>& abs_time);
37
38	private:
39	ptrdiff_t counter; // exposition only
40	};
41
42	using binary_semaphore = counting_semaphore<1>;
43
44	}
45
46	*/
47
48	#include <__config>
49	#include <__threading_support>
50	#include <atomic>
51	#include <cassert>
52
53	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
54	#pragma GCC system_header
55	#endif
56
57	#ifdef _LIBCPP_HAS_NO_THREADS
58	# error <semaphore> is not supported on this single threaded system
59	#endif
60
61	#if _LIBCPP_STD_VER >= 14
62
63	_LIBCPP_BEGIN_NAMESPACE_STD
64
65	/*
66
67	__atomic_semaphore_base is the general-case implementation, to be used for
68	user-requested least-max values that exceed the OS implementation support
69	(incl. when the OS has no support of its own) and for binary semaphores.
70
71	It is a typical Dijsktra semaphore algorithm over atomics, wait and notify
72	functions. It avoids contention against users' own use of those facilities.
73
74	*/
75
76	class __atomic_semaphore_base
77	{
78	__atomic_base<ptrdiff_t> __a;
79
80	public:
81	_LIBCPP_INLINE_VISIBILITY
82	__atomic_semaphore_base(ptrdiff_t __count) : __a(__count)
83	{
84	}
85	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
86	void release(ptrdiff_t __update = 1)
87	{
88	if(0 < __a.fetch_add(__update, memory_order_release))
89	;
90	else if(__update > 1)
91	__a.notify_all();
92	else
93	__a.notify_one();
94	}
95	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
96	void acquire()
97	{
98	auto const __test_fn = [=]() -> bool {
99	auto __old = __a.load(memory_order_relaxed);
100	return (__old != 0) && __a.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed);
101	};
102	__cxx_atomic_wait(&__a.__a_, __test_fn);
103	}
104	template <class Rep, class Period>
105	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
106	bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
107	{
108	auto const __test_fn = [=]() -> bool {
109	auto __old = __a.load(memory_order_acquire);
110	while(1) {
111	if (__old == 0)
112	return false;
113	if(__a.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed))
114	return true;
115	}
116	};
117	return __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy(), __rel_time);
118	}
119	};
120
121	#ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
122
123	/*
124
125	__platform_semaphore_base a simple wrapper for the OS semaphore type. That
126	is, every call is routed to the OS in the most direct manner possible.
127
128	*/
129
130	class __platform_semaphore_base
131	{
132	__libcpp_semaphore_t __semaphore;
133
134	public:
135	_LIBCPP_INLINE_VISIBILITY
136	__platform_semaphore_base(ptrdiff_t __count) :
137	__semaphore()
138	{
139	__libcpp_semaphore_init(&__semaphore, __count);
140	}
141	_LIBCPP_INLINE_VISIBILITY
142	~__platform_semaphore_base() {
143	__libcpp_semaphore_destroy(&__semaphore);
144	}
145	_LIBCPP_INLINE_VISIBILITY
146	void release(ptrdiff_t __update)
147	{
148	for(; __update; --__update)
149	__libcpp_semaphore_post(&__semaphore);
150	}
151	_LIBCPP_INLINE_VISIBILITY
152	void acquire()
153	{
154	__libcpp_semaphore_wait(&__semaphore);
155	}
156	_LIBCPP_INLINE_VISIBILITY
157	bool try_acquire_for(chrono::nanoseconds __rel_time)
158	{
159	return __libcpp_semaphore_wait_timed(&__semaphore, __rel_time);
160	}
161	};
162
163	template<ptrdiff_t __least_max_value>
164	using __semaphore_base =
165	typename conditional<(__least_max_value > 1 && __least_max_value <= _LIBCPP_SEMAPHORE_MAX),
166	__platform_semaphore_base,
167	__atomic_semaphore_base>::type;
168
169	#else
170
171	template<ptrdiff_t __least_max_value>
172	using __semaphore_base =
173	__atomic_semaphore_base;
174
175	#define _LIBCPP_SEMAPHORE_MAX (numeric_limits<ptrdiff_t>::max())
176
177	#endif //_LIBCPP_NO_NATIVE_SEMAPHORES
178
179	template<ptrdiff_t __least_max_value = _LIBCPP_SEMAPHORE_MAX>
180	class counting_semaphore
181	{
182	__semaphore_base<__least_max_value> __semaphore;
183
184	public:
185	static constexpr ptrdiff_t max() noexcept {
186	return __least_max_value;
187	}
188
189	_LIBCPP_INLINE_VISIBILITY
190	counting_semaphore(ptrdiff_t __count = 0) : __semaphore(__count) { }
191	~counting_semaphore() = default;
192
193	counting_semaphore(const counting_semaphore&) = delete;
194	counting_semaphore& operator=(const counting_semaphore&) = delete;
195
196	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
197	void release(ptrdiff_t __update = 1)
198	{
199	__semaphore.release(__update);
200	}
201	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
202	void acquire()
203	{
204	__semaphore.acquire();
205	}
206	template<class Rep, class Period>
207	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
208	bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
209	{
210	return __semaphore.try_acquire_for(chrono::duration_cast<chrono::nanoseconds>(__rel_time));
211	}
212	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
213	bool try_acquire()
214	{
215	return try_acquire_for(chrono::nanoseconds::zero());
216	}
217	template <class Clock, class Duration>
218	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
219	bool try_acquire_until(chrono::time_point<Clock, Duration> const& __abs_time)
220	{
221	auto const current = Clock::now();
222	if(current >= __abs_time)
223	return try_acquire();
224	else
225	return try_acquire_for(__abs_time - current);
226	}
227	};
228
229	using binary_semaphore = counting_semaphore<1>;
230
231	_LIBCPP_END_NAMESPACE_STD
232
233	#endif // _LIBCPP_STD_VER >= 14
234
235	#endif //_LIBCPP_SEMAPHORE

lib/libcxx/include/set+12-6

 @@ -216,7 +216,8 @@ swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 template <class Key, class Compare, class Allocator, class Predicate>
-  void erase_if(set<Key, Compare, Allocator>& c, Predicate pred);  // C++20
+typename set<Key, Compare, Allocator>::size_type
+erase_if(set<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 template <class Key, class Compare = less<Key>,
           class Allocator = allocator<Key>>
 @@ -417,7 +418,8 @@ swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 template <class Key, class Compare, class Allocator, class Predicate>
-  void erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
+typename multiset<Key, Compare, Allocator>::size_type
+erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 }  // std
 @@ -960,8 +962,10 @@ swap(set<_Key, _Compare, _Allocator>& __x,
 #if _LIBCPP_STD_VER > 17
 template <class _Key, class _Compare, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred)
+    typename set<_Key, _Compare, _Allocator>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 template <class _Key, class _Compare = less<_Key>,
 @@ -1484,8 +1488,10 @@ swap(multiset<_Key, _Compare, _Allocator>& __x,
 #if _LIBCPP_STD_VER > 17
 template <class _Key, class _Compare, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred)
+    typename multiset<_Key, _Compare, _Allocator>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/span+64-106

...	@@ -46,15 +46,13 @@ public:	...	@@ -46,15 +46,13 @@ public:
46	using reference = element_type&;	46	using reference = element_type&;
47	using const_reference = const element_type&;	47	using const_reference = const element_type&;
48	using iterator = implementation-defined;	48	using iterator = implementation-defined;
49	using const_iterator = implementation-defined;
50	using reverse_iterator = std::reverse_iterator<iterator>;	49	using reverse_iterator = std::reverse_iterator<iterator>;
51	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
52	static constexpr size_type extent = Extent;	50	static constexpr size_type extent = Extent;
53		51
54	// [span.cons], span constructors, copy, assignment, and destructor	52	// [span.cons], span constructors, copy, assignment, and destructor
55	constexpr span() noexcept;	53	constexpr span() noexcept;
56	constexpr span(pointer ptr, size_type count);	54	constexpr explicit(Extent != dynamic_extent) span(pointer ptr, size_type count);
57	constexpr span(pointer firstElem, pointer lastElem);	55	constexpr explicit(Extent != dynamic_extent) span(pointer firstElem, pointer lastElem);
58	template <size_t N>	56	template <size_t N>
59	constexpr span(element_type (&arr)[N]) noexcept;	57	constexpr span(element_type (&arr)[N]) noexcept;
60	template <size_t N>	58	template <size_t N>
...	@@ -62,12 +60,12 @@ public:	...	@@ -62,12 +60,12 @@ public:
62	template <size_t N>	60	template <size_t N>
63	constexpr span(const array<value_type, N>& arr) noexcept;	61	constexpr span(const array<value_type, N>& arr) noexcept;
64	template <class Container>	62	template <class Container>
65	constexpr span(Container& cont);	63	constexpr explicit(Extent != dynamic_extent) span(Container& cont);
66	template <class Container>	64	template <class Container>
67	constexpr span(const Container& cont);	65	constexpr explicit(Extent != dynamic_extent) span(const Container& cont);
68	constexpr span(const span& other) noexcept = default;	66	constexpr span(const span& other) noexcept = default;
69	template <class OtherElementType, size_t OtherExtent>	67	template <class OtherElementType, size_t OtherExtent>
70	constexpr span(const span<OtherElementType, OtherExtent>& s) noexcept;	68	constexpr explicit(Extent != dynamic_extent) span(const span<OtherElementType, OtherExtent>& s) noexcept;
71	~span() noexcept = default;	69	~span() noexcept = default;
72	constexpr span& operator=(const span& other) noexcept = default;	70	constexpr span& operator=(const span& other) noexcept = default;
73		71
...	@@ -97,12 +95,8 @@ public:	...	@@ -97,12 +95,8 @@ public:
97	// [span.iterators], span iterator support	95	// [span.iterators], span iterator support
98	constexpr iterator begin() const noexcept;	96	constexpr iterator begin() const noexcept;
99	constexpr iterator end() const noexcept;	97	constexpr iterator end() const noexcept;
100	constexpr const_iterator cbegin() const noexcept;
101	constexpr const_iterator cend() const noexcept;
102	constexpr reverse_iterator rbegin() const noexcept;	98	constexpr reverse_iterator rbegin() const noexcept;
103	constexpr reverse_iterator rend() const noexcept;	99	constexpr reverse_iterator rend() const noexcept;
104	constexpr const_reverse_iterator crbegin() const noexcept;
105	constexpr const_reverse_iterator crend() const noexcept;
106		100
107	private:	101	private:
108	pointer data_; // exposition only	102	pointer data_; // exposition only
...	@@ -129,11 +123,10 @@ template<class Container>	...	@@ -129,11 +123,10 @@ template<class Container>
129	*/	123	*/
130		124
131	#include <__config>	125	#include <__config>
132	#include <cstddef> // for ptrdiff_t
133	#include <iterator> // for iterators
134	#include <array> // for array	126	#include <array> // for array
135	#include <type_traits> // for remove_cv, etc
136	#include <cstddef> // for byte	127	#include <cstddef> // for byte
		128	#include <iterator> // for iterators
		129	#include <type_traits> // for remove_cv, etc
137		130
138	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	131	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
139	#pragma GCC system_header	132	#pragma GCC system_header
...	@@ -143,7 +136,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -143,7 +136,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
143		136
144	#if _LIBCPP_STD_VER > 17	137	#if _LIBCPP_STD_VER > 17
145		138
146	inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();	139	inline constexpr size_t dynamic_extent = (numeric_limits<size_t>::max)();
147	template <typename _Tp, size_t _Extent = dynamic_extent> class span;	140	template <typename _Tp, size_t _Extent = dynamic_extent> class span;
148		141
149		142
...	@@ -202,27 +195,49 @@ public:	...	@@ -202,27 +195,49 @@ public:
202	using reference = _Tp &;	195	using reference = _Tp &;
203	using const_reference = const _Tp &;	196	using const_reference = const _Tp &;
204	using iterator = __wrap_iter<pointer>;	197	using iterator = __wrap_iter<pointer>;
205	using const_iterator = __wrap_iter<const_pointer>;
206	using reverse_iterator = _VSTD::reverse_iterator<iterator>;	198	using reverse_iterator = _VSTD::reverse_iterator<iterator>;
207	using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
208		199
209	static constexpr size_type extent = _Extent;	200	static constexpr size_type extent = _Extent;
210		201
211	// [span.cons], span constructors, copy, assignment, and destructor	202	// [span.cons], span constructors, copy, assignment, and destructor
212	_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}	203	template <size_t _Sz = _Extent, enable_if_t<_Sz == 0, nullptr_t> = nullptr>
213	{ static_assert(_Extent == 0, "Can't default construct a statically sized span with size > 0"); }	204	_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr} {}
214		205
215	constexpr span (const span&) noexcept = default;	206	constexpr span (const span&) noexcept = default;
216	constexpr span& operator=(const span&) noexcept = default;	207	constexpr span& operator=(const span&) noexcept = default;
217		208
218	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, size_type __count) : __data{__ptr}	209	_LIBCPP_INLINE_VISIBILITY constexpr explicit span(pointer __ptr, size_type __count) : __data{__ptr}
219	{ (void)__count; _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (ptr, len)"); }	210	{ (void)__count; _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (ptr, len)"); }
220	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}	211	_LIBCPP_INLINE_VISIBILITY constexpr explicit span(pointer __f, pointer __l) : __data{__f}
221	{ (void)__l; _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }	212	{ (void)__l; _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }
222		213
223	_LIBCPP_INLINE_VISIBILITY constexpr span(element_type (&__arr)[_Extent]) noexcept : __data{__arr} {}	214	_LIBCPP_INLINE_VISIBILITY constexpr span(element_type (&__arr)[_Extent]) noexcept : __data{__arr} {}
224	_LIBCPP_INLINE_VISIBILITY constexpr span( array<value_type, _Extent>& __arr) noexcept : __data{__arr.data()} {}	215
225	_LIBCPP_INLINE_VISIBILITY constexpr span(const array<value_type, _Extent>& __arr) noexcept : __data{__arr.data()} {}	216	template <class _OtherElementType,
		217	enable_if_t<is_convertible_v<_OtherElementType()[], element_type ()[]>, nullptr_t> = nullptr>
		218	_LIBCPP_INLINE_VISIBILITY
		219	constexpr span(array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
		220
		221	template <class _OtherElementType,
		222	enable_if_t<is_convertible_v<const _OtherElementType()[], element_type ()[]>, nullptr_t> = nullptr>
		223	_LIBCPP_INLINE_VISIBILITY
		224	constexpr span(const array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
		225
		226	template <class _Container>
		227	_LIBCPP_INLINE_VISIBILITY
		228	constexpr explicit span( _Container& __c,
		229	enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr)
		230	: __data{_VSTD::data(__c)} {
		231	_LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (range)");
		232	}
		233
		234	template <class _Container>
		235	_LIBCPP_INLINE_VISIBILITY
		236	constexpr explicit span(const _Container& __c,
		237	enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, nullptr_t> = nullptr)
		238	: __data{_VSTD::data(__c)} {
		239	_LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (range)");
		240	}
226		241
227	template <class _OtherElementType>	242	template <class _OtherElementType>
228	_LIBCPP_INLINE_VISIBILITY	243	_LIBCPP_INLINE_VISIBILITY
...	@@ -234,7 +249,7 @@ public:	...	@@ -234,7 +249,7 @@ public:
234		249
235	template <class _OtherElementType>	250	template <class _OtherElementType>
236	_LIBCPP_INLINE_VISIBILITY	251	_LIBCPP_INLINE_VISIBILITY
237	constexpr span(const span<_OtherElementType, dynamic_extent>& __other,	252	constexpr explicit span(const span<_OtherElementType, dynamic_extent>& __other,
238	enable_if_t<	253	enable_if_t<
239	is_convertible_v<_OtherElementType()[], element_type ()[]>,	254	is_convertible_v<_OtherElementType()[], element_type ()[]>,
240	nullptr_t> = nullptr) noexcept	255	nullptr_t> = nullptr) noexcept
...	@@ -248,7 +263,7 @@ public:	...	@@ -248,7 +263,7 @@ public:
248	constexpr span<element_type, _Count> first() const noexcept	263	constexpr span<element_type, _Count> first() const noexcept
249	{	264	{
250	static_assert(_Count <= _Extent, "Count out of range in span::first()");	265	static_assert(_Count <= _Extent, "Count out of range in span::first()");
251	return {data(), _Count};	266	return span<element_type, _Count>{data(), _Count};
252	}	267	}
253		268
254	template <size_t _Count>	269	template <size_t _Count>
...	@@ -256,7 +271,7 @@ public:	...	@@ -256,7 +271,7 @@ public:
256	constexpr span<element_type, _Count> last() const noexcept	271	constexpr span<element_type, _Count> last() const noexcept
257	{	272	{
258	static_assert(_Count <= _Extent, "Count out of range in span::last()");	273	static_assert(_Count <= _Extent, "Count out of range in span::last()");
259	return {data() + size() - _Count, _Count};	274	return span<element_type, _Count>{data() + size() - _Count, _Count};
260	}	275	}
261		276
262	_LIBCPP_INLINE_VISIBILITY	277	_LIBCPP_INLINE_VISIBILITY
...	@@ -279,7 +294,10 @@ public:	...	@@ -279,7 +294,10 @@ public:
279	-> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>	294	-> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>
280	{	295	{
281	static_assert(_Offset <= _Extent, "Offset out of range in span::subspan()");	296	static_assert(_Offset <= _Extent, "Offset out of range in span::subspan()");
282	return {data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};	297	static_assert(_Count == dynamic_extent \|\| _Count <= _Extent - _Offset, "Offset + count out of range in span::subspan()");
		298
		299	using _ReturnType = span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>;
		300	return _ReturnType{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
283	}	301	}
284		302
285		303
...	@@ -291,7 +309,7 @@ public:	...	@@ -291,7 +309,7 @@ public:
291	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "Count out of range in span::subspan(offset, count)");	309	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "Count out of range in span::subspan(offset, count)");
292	if (__count == dynamic_extent)	310	if (__count == dynamic_extent)
293	return {data() + __offset, size() - __offset};	311	return {data() + __offset, size() - __offset};
294	_LIBCPP_ASSERT(__offset <= size() - __count, "count + offset out of range in span::subspan(offset, count)");	312	_LIBCPP_ASSERT(__count <= size() - __offset, "Offset + count out of range in span::subspan(offset, count)");
295	return {data() + __offset, __count};	313	return {data() + __offset, __count};
296	}	314	}
297		315
...	@@ -301,19 +319,19 @@ public:	...	@@ -301,19 +319,19 @@ public:
301		319
302	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept	320	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
303	{	321	{
304	_LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T,N>[] index out of bounds");	322	_LIBCPP_ASSERT(__idx < size(), "span<T,N>[] index out of bounds");
305	return __data[__idx];	323	return __data[__idx];
306	}	324	}
307		325
308	_LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept	326	_LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
309	{	327	{
310	static_assert(_Extent > 0, "span<T,N>[].front() on empty span");	328	_LIBCPP_ASSERT(!empty(), "span<T, N>::front() on empty span");
311	return __data[0];	329	return __data[0];
312	}	330	}
313		331
314	_LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept	332	_LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
315	{	333	{
316	static_assert(_Extent > 0, "span<T,N>[].back() on empty span");	334	_LIBCPP_ASSERT(!empty(), "span<T, N>::back() on empty span");
317	return __data[size()-1];	335	return __data[size()-1];
318	}	336	}
319		337
...	@@ -322,25 +340,14 @@ public:	...	@@ -322,25 +340,14 @@ public:
322	// [span.iter], span iterator support	340	// [span.iter], span iterator support
323	_LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }	341	_LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }
324	_LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }	342	_LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }
325	_LIBCPP_INLINE_VISIBILITY constexpr const_iterator cbegin() const noexcept { return const_iterator(data()); }
326	_LIBCPP_INLINE_VISIBILITY constexpr const_iterator cend() const noexcept { return const_iterator(data() + size()); }
327	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }	343	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
328	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }	344	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
329	_LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
330	_LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }
331
332	_LIBCPP_INLINE_VISIBILITY constexpr void swap(span &__other) noexcept
333	{
334	pointer __p = __data;
335	__data = __other.__data;
336	__other.__data = __p;
337	}
338		345
339	_LIBCPP_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept	346	_LIBCPP_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept
340	{ return {reinterpret_cast<const byte *>(data()), size_bytes()}; }	347	{ return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte *>(data()), size_bytes()}; }
341		348
342	_LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept	349	_LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept
343	{ return {reinterpret_cast<byte *>(data()), size_bytes()}; }	350	{ return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()}; }
344		351
345	private:	352	private:
346	pointer __data;	353	pointer __data;
...	@@ -363,9 +370,7 @@ public:	...	@@ -363,9 +370,7 @@ public:
363	using reference = _Tp &;	370	using reference = _Tp &;
364	using const_reference = const _Tp &;	371	using const_reference = const _Tp &;
365	using iterator = __wrap_iter<pointer>;	372	using iterator = __wrap_iter<pointer>;
366	using const_iterator = __wrap_iter<const_pointer>;
367	using reverse_iterator = _VSTD::reverse_iterator<iterator>;	373	using reverse_iterator = _VSTD::reverse_iterator<iterator>;
368	using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
369		374
370	static constexpr size_type extent = dynamic_extent;	375	static constexpr size_type extent = dynamic_extent;
371		376
...	@@ -382,13 +387,15 @@ public:	...	@@ -382,13 +387,15 @@ public:
382	_LIBCPP_INLINE_VISIBILITY	387	_LIBCPP_INLINE_VISIBILITY
383	constexpr span(element_type (&__arr)[_Sz]) noexcept : __data{__arr}, __size{_Sz} {}	388	constexpr span(element_type (&__arr)[_Sz]) noexcept : __data{__arr}, __size{_Sz} {}
384		389
385	template <size_t _Sz>	390	template <class _OtherElementType, size_t _Sz,
		391	enable_if_t<is_convertible_v<_OtherElementType()[], element_type ()[]>, nullptr_t> = nullptr>
386	_LIBCPP_INLINE_VISIBILITY	392	_LIBCPP_INLINE_VISIBILITY
387	constexpr span(array<value_type, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}	393	constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
388		394
389	template <size_t _Sz>	395	template <class _OtherElementType, size_t _Sz,
		396	enable_if_t<is_convertible_v<const _OtherElementType()[], element_type ()[]>, nullptr_t> = nullptr>
390	_LIBCPP_INLINE_VISIBILITY	397	_LIBCPP_INLINE_VISIBILITY
391	constexpr span(const array<value_type, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}	398	constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
392		399
393	template <class _Container>	400	template <class _Container>
394	_LIBCPP_INLINE_VISIBILITY	401	_LIBCPP_INLINE_VISIBILITY
...	@@ -418,7 +425,7 @@ public:	...	@@ -418,7 +425,7 @@ public:
418	constexpr span<element_type, _Count> first() const noexcept	425	constexpr span<element_type, _Count> first() const noexcept
419	{	426	{
420	_LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::first()");	427	_LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::first()");
421	return {data(), _Count};	428	return span<element_type, _Count>{data(), _Count};
422	}	429	}
423		430
424	template <size_t _Count>	431	template <size_t _Count>
...	@@ -426,7 +433,7 @@ public:	...	@@ -426,7 +433,7 @@ public:
426	constexpr span<element_type, _Count> last() const noexcept	433	constexpr span<element_type, _Count> last() const noexcept
427	{	434	{
428	_LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::last()");	435	_LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::last()");
429	return {data() + size() - _Count, _Count};	436	return span<element_type, _Count>{data() + size() - _Count, _Count};
430	}	437	}
431		438
432	_LIBCPP_INLINE_VISIBILITY	439	_LIBCPP_INLINE_VISIBILITY
...	@@ -445,11 +452,11 @@ public:	...	@@ -445,11 +452,11 @@ public:
445		452
446	template <size_t _Offset, size_t _Count = dynamic_extent>	453	template <size_t _Offset, size_t _Count = dynamic_extent>
447	_LIBCPP_INLINE_VISIBILITY	454	_LIBCPP_INLINE_VISIBILITY
448	constexpr span<_Tp, dynamic_extent> subspan() const noexcept	455	constexpr span<element_type, _Count> subspan() const noexcept
449	{	456	{
450	_LIBCPP_ASSERT(_Offset <= size(), "Offset out of range in span::subspan()");	457	_LIBCPP_ASSERT(_Offset <= size(), "Offset out of range in span::subspan()");
451	_LIBCPP_ASSERT(_Count == dynamic_extent \|\| _Offset + _Count <= size(), "Count out of range in span::subspan()");	458	_LIBCPP_ASSERT(_Count == dynamic_extent \|\| _Count <= size() - _Offset, "Offset + count out of range in span::subspan()");
452	return {data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};	459	return span<element_type, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
453	}	460	}
454		461
455	constexpr span<element_type, dynamic_extent>	462	constexpr span<element_type, dynamic_extent>
...	@@ -460,7 +467,7 @@ public:	...	@@ -460,7 +467,7 @@ public:
460	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "count out of range in span::subspan(offset, count)");	467	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "count out of range in span::subspan(offset, count)");
461	if (__count == dynamic_extent)	468	if (__count == dynamic_extent)
462	return {data() + __offset, size() - __offset};	469	return {data() + __offset, size() - __offset};
463	_LIBCPP_ASSERT(__offset <= size() - __count, "Offset + count out of range in span::subspan(offset, count)");	470	_LIBCPP_ASSERT(__count <= size() - __offset, "Offset + count out of range in span::subspan(offset, count)");
464	return {data() + __offset, __count};	471	return {data() + __offset, __count};
465	}	472	}
466		473
...	@@ -470,7 +477,7 @@ public:	...	@@ -470,7 +477,7 @@ public:
470		477
471	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept	478	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
472	{	479	{
473	_LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T>[] index out of bounds");	480	_LIBCPP_ASSERT(__idx < size(), "span<T>[] index out of bounds");
474	return __data[__idx];	481	return __data[__idx];
475	}	482	}
476		483
...	@@ -492,23 +499,8 @@ public:	...	@@ -492,23 +499,8 @@ public:
492	// [span.iter], span iterator support	499	// [span.iter], span iterator support
493	_LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }	500	_LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }
494	_LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }	501	_LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }
495	_LIBCPP_INLINE_VISIBILITY constexpr const_iterator cbegin() const noexcept { return const_iterator(data()); }
496	_LIBCPP_INLINE_VISIBILITY constexpr const_iterator cend() const noexcept { return const_iterator(data() + size()); }
497	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }	502	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
498	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }	503	_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
499	_LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
500	_LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }
501
502	_LIBCPP_INLINE_VISIBILITY constexpr void swap(span &__other) noexcept
503	{
504	pointer __p = __data;
505	__data = __other.__data;
506	__other.__data = __p;
507
508	size_type __sz = __size;
509	__size = __other.__size;
510	__other.__size = __sz;
511	}
512		504
513	_LIBCPP_INLINE_VISIBILITY span<const byte, dynamic_extent> __as_bytes() const noexcept	505	_LIBCPP_INLINE_VISIBILITY span<const byte, dynamic_extent> __as_bytes() const noexcept
514	{ return {reinterpret_cast<const byte *>(data()), size_bytes()}; }	506	{ return {reinterpret_cast<const byte *>(data()), size_bytes()}; }
...	@@ -521,34 +513,6 @@ private:	...	@@ -521,34 +513,6 @@ private:
521	size_type __size;	513	size_type __size;
522	};	514	};
523		515
524	// tuple interface
525	template <class _Tp, size_t _Size>
526	struct _LIBCPP_TEMPLATE_VIS tuple_size<span<_Tp, _Size>>
527	: public integral_constant<size_t, _Size> {};
528
529	template <class _Tp>
530	struct _LIBCPP_TEMPLATE_VIS tuple_size<span<_Tp, dynamic_extent>>; // declared but not defined
531
532
533	template <size_t _Ip, class _Tp, size_t _Size>
534	struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, span<_Tp, _Size>>
535	{
536	static_assert( dynamic_extent != _Size, "std::tuple_element<> not supported for std::span<T, dynamic_extent>");
537	static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::span)");
538	typedef _Tp type;
539	};
540
541	template <size_t _Ip, class _Tp, size_t _Size>
542	_LIBCPP_INLINE_VISIBILITY constexpr
543	_Tp&
544	get(span<_Tp, _Size> __s) noexcept
545	{
546	static_assert( dynamic_extent != _Size, "std::get<> not supported for std::span<T, dynamic_extent>");
547	static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::span)");
548	return __s[_Ip];
549	}
550
551
552	// as_bytes & as_writable_bytes	516	// as_bytes & as_writable_bytes
553	template <class _Tp, size_t _Extent>	517	template <class _Tp, size_t _Extent>
554	_LIBCPP_INLINE_VISIBILITY	518	_LIBCPP_INLINE_VISIBILITY
...	@@ -562,12 +526,6 @@ auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept	...	@@ -562,12 +526,6 @@ auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept
562	-> enable_if_t<!is_const_v<_Tp>, decltype(__s.__as_writable_bytes())>	526	-> enable_if_t<!is_const_v<_Tp>, decltype(__s.__as_writable_bytes())>
563	{ return __s.__as_writable_bytes(); }	527	{ return __s.__as_writable_bytes(); }
564		528
565	template <class _Tp, size_t _Extent>
566	_LIBCPP_INLINE_VISIBILITY
567	constexpr void swap(span<_Tp, _Extent> &__lhs, span<_Tp, _Extent> &__rhs) noexcept
568	{ __lhs.swap(__rhs); }
569
570
571	// Deduction guides	529	// Deduction guides
572	template<class _Tp, size_t _Sz>	530	template<class _Tp, size_t _Sz>
573	span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;	531	span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;

lib/libcxx/include/stddef.h+1-7

 @@ -31,7 +31,7 @@ Types:
     ptrdiff_t
     size_t
-    max_align_t
+    max_align_t // C++11
     nullptr_t
 */
 @@ -51,12 +51,6 @@ extern "C++" {
 using std::nullptr_t;
 }
-// Re-use the compiler's <stddef.h> max_align_t where possible.
-#if !defined(__CLANG_MAX_ALIGN_T_DEFINED) && !defined(_GCC_MAX_ALIGN_T) && \
-    !defined(__DEFINED_max_align_t) && !defined(__NetBSD__)
-typedef long double max_align_t;
-#endif
 #endif
 #endif  // _LIBCPP_STDDEF_H

lib/libcxx/include/stdexcept+7

...	@@ -129,6 +129,7 @@ public:	...	@@ -129,6 +129,7 @@ public:
129	_LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s) : logic_error(__s) {}	129	_LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s) : logic_error(__s) {}
130		130
131	#ifndef _LIBCPP_ABI_VCRUNTIME	131	#ifndef _LIBCPP_ABI_VCRUNTIME
		132	domain_error(const domain_error&) _NOEXCEPT = default;
132	virtual ~domain_error() _NOEXCEPT;	133	virtual ~domain_error() _NOEXCEPT;
133	#endif	134	#endif
134	};	135	};
...	@@ -141,6 +142,7 @@ public:	...	@@ -141,6 +142,7 @@ public:
141	_LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s) : logic_error(__s) {}	142	_LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s) : logic_error(__s) {}
142		143
143	#ifndef _LIBCPP_ABI_VCRUNTIME	144	#ifndef _LIBCPP_ABI_VCRUNTIME
		145	invalid_argument(const invalid_argument&) _NOEXCEPT = default;
144	virtual ~invalid_argument() _NOEXCEPT;	146	virtual ~invalid_argument() _NOEXCEPT;
145	#endif	147	#endif
146	};	148	};
...	@@ -152,6 +154,7 @@ public:	...	@@ -152,6 +154,7 @@ public:
152	_LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}	154	_LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
153	_LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s) : logic_error(__s) {}	155	_LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s) : logic_error(__s) {}
154	#ifndef _LIBCPP_ABI_VCRUNTIME	156	#ifndef _LIBCPP_ABI_VCRUNTIME
		157	length_error(const length_error&) _NOEXCEPT = default;
155	virtual ~length_error() _NOEXCEPT;	158	virtual ~length_error() _NOEXCEPT;
156	#endif	159	#endif
157	};	160	};
...	@@ -164,6 +167,7 @@ public:	...	@@ -164,6 +167,7 @@ public:
164	_LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s) : logic_error(__s) {}	167	_LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s) : logic_error(__s) {}
165		168
166	#ifndef _LIBCPP_ABI_VCRUNTIME	169	#ifndef _LIBCPP_ABI_VCRUNTIME
		170	out_of_range(const out_of_range&) _NOEXCEPT = default;
167	virtual ~out_of_range() _NOEXCEPT;	171	virtual ~out_of_range() _NOEXCEPT;
168	#endif	172	#endif
169	};	173	};
...	@@ -176,6 +180,7 @@ public:	...	@@ -176,6 +180,7 @@ public:
176	_LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s) : runtime_error(__s) {}	180	_LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s) : runtime_error(__s) {}
177		181
178	#ifndef _LIBCPP_ABI_VCRUNTIME	182	#ifndef _LIBCPP_ABI_VCRUNTIME
		183	range_error(const range_error&) _NOEXCEPT = default;
179	virtual ~range_error() _NOEXCEPT;	184	virtual ~range_error() _NOEXCEPT;
180	#endif	185	#endif
181	};	186	};
...	@@ -188,6 +193,7 @@ public:	...	@@ -188,6 +193,7 @@ public:
188	_LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s) : runtime_error(__s) {}	193	_LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s) : runtime_error(__s) {}
189		194
190	#ifndef _LIBCPP_ABI_VCRUNTIME	195	#ifndef _LIBCPP_ABI_VCRUNTIME
		196	overflow_error(const overflow_error&) _NOEXCEPT = default;
191	virtual ~overflow_error() _NOEXCEPT;	197	virtual ~overflow_error() _NOEXCEPT;
192	#endif	198	#endif
193	};	199	};
...	@@ -200,6 +206,7 @@ public:	...	@@ -200,6 +206,7 @@ public:
200	_LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s) : runtime_error(__s) {}	206	_LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s) : runtime_error(__s) {}
201		207
202	#ifndef _LIBCPP_ABI_VCRUNTIME	208	#ifndef _LIBCPP_ABI_VCRUNTIME
		209	underflow_error(const underflow_error&) _NOEXCEPT = default;
203	virtual ~underflow_error() _NOEXCEPT;	210	virtual ~underflow_error() _NOEXCEPT;
204	#endif	211	#endif
205	};	212	};

lib/libcxx/include/stdlib.h+58-6

...	@@ -7,16 +7,12 @@	...	@@ -7,16 +7,12 @@
7	//	7	//
8	//===----------------------------------------------------------------------===//	8	//===----------------------------------------------------------------------===//
9		9
10	#if defined(__need_malloc_and_calloc) \|\| defined(_LIBCPP_STDLIB_INCLUDE_NEXT)	10	#if defined(__need_malloc_and_calloc)
11		11
12	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	12	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
13	#pragma GCC system_header	13	#pragma GCC system_header
14	#endif	14	#endif
15		15
16	#if defined(_LIBCPP_STDLIB_INCLUDE_NEXT)
17	#undef _LIBCPP_STDLIB_INCLUDE_NEXT
18	#endif
19
20	#include_next <stdlib.h>	16	#include_next <stdlib.h>
21		17
22	#elif !defined(_LIBCPP_STDLIB_H)	18	#elif !defined(_LIBCPP_STDLIB_H)
...	@@ -97,7 +93,63 @@ void *aligned_alloc(size_t alignment, size_t size); // C11	...	@@ -97,7 +93,63 @@ void *aligned_alloc(size_t alignment, size_t size); // C11
97	#include_next <stdlib.h>	93	#include_next <stdlib.h>
98		94
99	#ifdef __cplusplus	95	#ifdef __cplusplus
100	#include <math.h>	96	extern "C++" {
		97	// abs
		98
		99	#undef abs
		100	#undef labs
		101	#ifndef _LIBCPP_HAS_NO_LONG_LONG
		102	#undef llabs
		103	#endif
		104
		105	// MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
		106	#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
		107	inline _LIBCPP_INLINE_VISIBILITY long abs(long __x) _NOEXCEPT {
		108	return __builtin_labs(__x);
		109	}
		110	#ifndef _LIBCPP_HAS_NO_LONG_LONG
		111	inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {
		112	return __builtin_llabs(__x);
		113	}
		114	#endif // _LIBCPP_HAS_NO_LONG_LONG
		115	#endif // !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
		116
		117	#if !(defined(_AIX) \|\| defined(__sun__))
		118	inline _LIBCPP_INLINE_VISIBILITY float abs(float __lcpp_x) _NOEXCEPT {
		119	return __builtin_fabsf(__lcpp_x); // Use builtins to prevent needing math.h
		120	}
		121
		122	inline _LIBCPP_INLINE_VISIBILITY double abs(double __lcpp_x) _NOEXCEPT {
		123	return __builtin_fabs(__lcpp_x);
		124	}
		125
		126	inline _LIBCPP_INLINE_VISIBILITY long double
		127	abs(long double __lcpp_x) _NOEXCEPT {
		128	return __builtin_fabsl(__lcpp_x);
		129	}
		130	#endif // !(defined(_AIX) \|\| defined(__sun__))
		131
		132	// div
		133
		134	#undef div
		135	#undef ldiv
		136	#ifndef _LIBCPP_HAS_NO_LONG_LONG
		137	#undef lldiv
		138	#endif
		139
		140	// MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
		141	#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__) && !defined(_AIX)
		142	inline _LIBCPP_INLINE_VISIBILITY ldiv_t div(long __x, long __y) _NOEXCEPT {
		143	return ::ldiv(__x, __y);
		144	}
		145	#ifndef _LIBCPP_HAS_NO_LONG_LONG
		146	inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x,
		147	long long __y) _NOEXCEPT {
		148	return ::lldiv(__x, __y);
		149	}
		150	#endif // _LIBCPP_HAS_NO_LONG_LONG
		151	#endif // _LIBCPP_MSVCRT / __sun__ / _AIX
		152	} // extern "C++"
101	#endif // __cplusplus	153	#endif // __cplusplus
102		154
103	#endif // _LIBCPP_STDLIB_H	155	#endif // _LIBCPP_STDLIB_H

lib/libcxx/include/string+313-185

 @@ -437,9 +437,11 @@ basic_istream<charT, traits>&
 getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
 template<class charT, class traits, class Allocator, class U>
-void erase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20
+typename basic_string<charT, traits, Allocator>::size_type
+erase(basic_string<charT, traits, Allocator>& c, const U& value);    // C++20
 template<class charT, class traits, class Allocator, class Predicate>
-void erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
+typename basic_string<charT, traits, Allocator>::size_type
+erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
 typedef basic_string<char>    string;
 typedef basic_string<wchar_t> wstring;
 @@ -643,9 +645,10 @@ struct __libcpp_string_gets_noexcept_iterator
     : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value || __libcpp_string_gets_noexcept_iterator_impl<_Iter>::value) {};
 template <class _CharT, class _Traits, class _Tp>
-struct __can_be_converted_to_string_view : public _LIBCPP_BOOL_CONSTANT(
+struct __can_be_converted_to_string_view : public _BoolConstant<
-    ( is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
+      is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
-     !is_convertible<const _Tp&, const _CharT*>::value)) {};
+     !is_convertible<const _Tp&, const _CharT*>::value
+    > {};
 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 @@ -688,13 +691,8 @@ public:
     static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
-#if defined(_LIBCPP_RAW_ITERATORS)
-    typedef pointer                                      iterator;
-    typedef const_pointer                                const_iterator;
-#else  // defined(_LIBCPP_RAW_ITERATORS)
     typedef __wrap_iter<pointer>                         iterator;
     typedef __wrap_iter<const_pointer>                   const_iterator;
-#endif  // defined(_LIBCPP_RAW_ITERATORS)
     typedef _VSTD::reverse_iterator<iterator>             reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator>       const_reverse_iterator;
 @@ -784,6 +782,7 @@ private:
     __compressed_pair<__rep, allocator_type> __r_;
 public:
+    _LIBCPP_FUNC_VIS
     static const size_type npos = -1;
     _LIBCPP_INLINE_VISIBILITY basic_string()
 @@ -812,7 +811,7 @@ public:
     basic_string(basic_string&& __str, const allocator_type& __a);
 #endif  // _LIBCPP_CXX03_LANG
-    template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
+    template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
     _LIBCPP_INLINE_VISIBILITY
     basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
       _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
 @@ -822,7 +821,7 @@ public:
 #   endif
     }
-    template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
+    template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
         _LIBCPP_INLINE_VISIBILITY
         basic_string(const _CharT* __s, const _Allocator& __a);
 @@ -833,7 +832,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     basic_string(size_type __n, _CharT __c);
-    template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
+    template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
         _LIBCPP_INLINE_VISIBILITY
         basic_string(size_type __n, _CharT __c, const _Allocator& __a);
 @@ -843,23 +842,24 @@ public:
     basic_string(const basic_string& __str, size_type __pos,
                  const _Allocator& __a = _Allocator());
-    template<class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
+    template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         basic_string(const _Tp& __t, size_type __pos, size_type __n,
-                              const allocator_type& __a = allocator_type());
+                     const allocator_type& __a = allocator_type());
-    template<class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
+    template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
+                                          !__is_same_uncvref<_Tp, basic_string>::value> >
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         explicit basic_string(const _Tp& __t);
-    template<class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
+    template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         explicit basic_string(const _Tp& __t, const allocator_type& __a);
-    template<class _InputIterator, class = typename enable_if<__is_cpp17_input_iterator<_InputIterator>::value>::type>
+    template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> >
         _LIBCPP_INLINE_VISIBILITY
         basic_string(_InputIterator __first, _InputIterator __last);
-    template<class _InputIterator, class = typename enable_if<__is_cpp17_input_iterator<_InputIterator>::value>::type>
+    template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> >
         _LIBCPP_INLINE_VISIBILITY
         basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
 #ifndef _LIBCPP_CXX03_LANG
 @@ -876,7 +876,7 @@ public:
     basic_string& operator=(const basic_string& __str);
-    template <class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
+    template <class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
     basic_string& operator=(const _Tp& __t)
         {__self_view __sv = __t; return assign(__sv);}
 @@ -976,11 +976,12 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
-            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
+            && !__is_same_uncvref<_Tp, basic_string >::value,
             basic_string&
-        >::type
+        >
                                             operator+=(const _Tp& __t)            {__self_view __sv = __t; return append(__sv);}
     _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s)     {return append(__s);}
     _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c)            {push_back(__c); return *this;}
 @@ -993,21 +994,22 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf<
-        <
+            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
-            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+            && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
-        >::type
+        >
                   append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); }
     basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
-            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
+            && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
-        >::type
+        >
                   append(const _Tp& __t, size_type __pos, size_type __n=npos);
     basic_string& append(const value_type* __s, size_type __n);
     basic_string& append(const value_type* __s);
 @@ -1021,12 +1023,12 @@ public:
     basic_string& __append_forward_unsafe(_ForwardIterator, _ForwardIterator);
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __is_exactly_cpp17_input_iterator<_InputIterator>::value
                 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
             basic_string&
-        >::type
+        >
     _LIBCPP_INLINE_VISIBILITY
     append(_InputIterator __first, _InputIterator __last) {
       const basic_string __temp (__first, __last, __alloc());
 @@ -1035,12 +1037,12 @@ public:
     }
     template<class _ForwardIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value
                 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
             basic_string&
-        >::type
+        >
     _LIBCPP_INLINE_VISIBILITY
     append(_ForwardIterator __first, _ForwardIterator __last) {
       return __append_forward_unsafe(__first, __last);
 @@ -1061,11 +1063,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
-        >::type
+        >
                  assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
     _LIBCPP_INLINE_VISIBILITY
     basic_string& assign(const basic_string& __str) { return *this = __str; }
 @@ -1078,32 +1080,33 @@ public:
     basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
-            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
+            && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
-        >::type
+        >
                   assign(const _Tp & __t, size_type __pos, size_type __n=npos);
     basic_string& assign(const value_type* __s, size_type __n);
     basic_string& assign(const value_type* __s);
     basic_string& assign(size_type __n, value_type __c);
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
            __is_exactly_cpp17_input_iterator<_InputIterator>::value
                 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
             basic_string&
-        >::type
+        >
         assign(_InputIterator __first, _InputIterator __last);
     template<class _ForwardIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value
                  && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
             basic_string&
-        >::type
+        >
         assign(_ForwardIterator __first, _ForwardIterator __last);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
 @@ -1115,21 +1118,21 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
-        >::type
+        >
                  insert(size_type __pos1, const _Tp& __t)
     { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); }
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
-            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
-        >::type
+        >
                   insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
     basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
     basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
 @@ -1140,21 +1143,21 @@ public:
     iterator      insert(const_iterator __pos, size_type __n, value_type __c);
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
            __is_exactly_cpp17_input_iterator<_InputIterator>::value
                 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
             iterator
-        >::type
+        >
         insert(const_iterator __pos, _InputIterator __first, _InputIterator __last);
     template<class _ForwardIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value
                  && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
             iterator
-        >::type
+        >
         insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
 @@ -1173,20 +1176,20 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
-        >::type
+        >
                   replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); }
     basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos);
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
-            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string>::value,
             basic_string&
-        >::type
+        >
                   replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
     basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
     basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
 @@ -1196,11 +1199,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             basic_string&
-        >::type
+        >
                   replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
     _LIBCPP_INLINE_VISIBILITY
 @@ -1211,11 +1214,11 @@ public:
     basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
     template<class _InputIterator>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __is_cpp17_input_iterator<_InputIterator>::value,
             basic_string&
-        >::type
+        >
         replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
 @@ -1253,11 +1256,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
-        >::type
+        >
               find(const _Tp& __t, size_type __pos = 0) const;
     size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
 @@ -1269,11 +1272,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
-        >::type
+        >
               rfind(const _Tp& __t, size_type __pos = npos) const;
     size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
 @@ -1285,11 +1288,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
-        >::type
+        >
               find_first_of(const _Tp& __t, size_type __pos = 0) const;
     size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
 @@ -1302,11 +1305,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
-        >::type
+        >
               find_last_of(const _Tp& __t, size_type __pos = npos) const;
     size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
 @@ -1319,11 +1322,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
-        >::type
+        >
               find_first_not_of(const _Tp &__t, size_type __pos = 0) const;
     size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
 @@ -1336,11 +1339,11 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             size_type
-        >::type
+        >
               find_last_not_of(const _Tp& __t, size_type __pos = npos) const;
     size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
 @@ -1353,20 +1356,20 @@ public:
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             int
-        >::type
+        >
         compare(const _Tp &__t) const;
     template <class _Tp>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    typename enable_if
+    _EnableIf
         <
             __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
             int
-        >::type
+        >
          compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
     _LIBCPP_INLINE_VISIBILITY
 @@ -1375,11 +1378,11 @@ public:
     template <class _Tp>
     inline _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
+        _EnableIf
         <
-            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+            __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string>::value,
             int
-        >::type
+        >
         compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
     int compare(const value_type* __s) const _NOEXCEPT;
     int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
 @@ -1543,22 +1546,30 @@ private:
     inline
     void __init(size_type __n, value_type __c);
+    // Slow path for the (inlined) copy constructor for 'long' strings.
+    // Always externally instantiated and not inlined.
+    // Requires that __s is zero terminated.
+    // The main reason for this function to exist is because for unstable, we
+    // want to allow inlining of the copy constructor. However, we don't want
+    // to call the __init() functions as those are marked as inline which may
+    // result in over-aggressive inlining by the compiler, where our aim is
+    // to only inline the fast path code directly in the ctor.
+    void __init_copy_ctor_external(const value_type* __s, size_type __sz);
     template <class _InputIterator>
     inline
-    typename enable_if
+    _EnableIf
     <
-        __is_exactly_cpp17_input_iterator<_InputIterator>::value,
+        __is_exactly_cpp17_input_iterator<_InputIterator>::value
-        void
+    >
-    >::type
     __init(_InputIterator __first, _InputIterator __last);
     template <class _ForwardIterator>
     inline
-    typename enable_if
+    _EnableIf
     <
-        __is_cpp17_forward_iterator<_ForwardIterator>::value,
+        __is_cpp17_forward_iterator<_ForwardIterator>::value
-        void
+    >
-    >::type
     __init(_ForwardIterator __first, _ForwardIterator __last);
     void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
 @@ -1567,9 +1578,19 @@ private:
                                size_type __n_copy,  size_type __n_del,
                                size_type __n_add, const value_type* __p_new_stuff);
+    // __assign_no_alias is invoked for assignment operations where we
+    // have proof that the input does not alias the current instance.
+    // For example, operator=(basic_string) performs a 'self' check.
+    template <bool __is_short>
+    basic_string& __assign_no_alias(const value_type* __s, size_type __n);
     _LIBCPP_INLINE_VISIBILITY
     void __erase_to_end(size_type __pos);
+    // __erase_external_with_move is invoked for erase() invocations where
+    // `n ~= npos`, likely requiring memory moves on the string data.
+    void __erase_external_with_move(size_type __pos, size_type __n);
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const basic_string& __str)
         {__copy_assign_alloc(__str, integral_constant<bool,
 @@ -1638,6 +1659,19 @@ private:
         _NOEXCEPT
         {}
+    basic_string& __assign_external(const value_type* __s);
+    basic_string& __assign_external(const value_type* __s, size_type __n);
+    // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
+    inline basic_string& __assign_short(const value_type* __s, size_type __n) {
+      pointer __p = __is_long()
+                        ? (__set_long_size(__n), __get_long_pointer())
+                        : (__set_short_size(__n), __get_short_pointer());
+      traits_type::move(_VSTD::__to_address(__p), __s, __n);
+      traits_type::assign(__p[__n], value_type());
+      return *this;
+    }
     _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
     _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);
 @@ -1648,12 +1682,23 @@ private:
     friend basic_string operator+<>(const basic_string&, value_type);
 };
+// These declarations must appear before any functions are implicitly used
+// so that they have the correct visibility specifier.
+#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
+#else
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
+#endif
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template<class _InputIterator,
          class _CharT = typename iterator_traits<_InputIterator>::value_type,
          class _Allocator = allocator<_CharT>,
-         class = typename enable_if<__is_cpp17_input_iterator<_InputIterator>::value, void>::type,
+         class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value>,
-         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type
+         class = _EnableIf<__is_allocator<_Allocator>::value>
          >
 basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
   -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
 @@ -1661,7 +1706,7 @@ basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
 template<class _CharT,
          class _Traits,
          class _Allocator = allocator<_CharT>,
-         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type
+         class = _EnableIf<__is_allocator<_Allocator>::value>
          >
 explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
   -> basic_string<_CharT, _Traits, _Allocator>;
 @@ -1669,14 +1714,13 @@ explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _A
 template<class _CharT,
          class _Traits,
          class _Allocator = allocator<_CharT>,
-         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type,
+         class = _EnableIf<__is_allocator<_Allocator>::value>,
          class _Sz = typename allocator_traits<_Allocator>::size_type
          >
 basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
   -> basic_string<_CharT, _Traits, _Allocator>;
 #endif
 template <class _CharT, class _Traits, class _Allocator>
 inline
 void
 @@ -1837,7 +1881,9 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
-        __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
+        __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
+                                  __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 @@ -1851,12 +1897,32 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
-        __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
+        __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
+                                  __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
+template <class _CharT, class _Traits, class _Allocator>
+void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
+    const value_type* __s, size_type __sz) {
+  pointer __p;
+  if (__sz < __min_cap) {
+    __p = __get_short_pointer();
+    __set_short_size(__sz);
+  } else {
+    if (__sz > max_size())
+      this->__throw_length_error();
+    size_t __cap = __recommend(__sz);
+    __p = __alloc_traits::allocate(__alloc(), __cap + 1);
+    __set_long_pointer(__p);
+    __set_long_cap(__cap + 1);
+    __set_long_size(__sz);
+  }
+  traits_type::copy(_VSTD::__to_address(__p), __s, __sz + 1);
+}
 #ifndef _LIBCPP_CXX03_LANG
 template <class _CharT, class _Traits, class _Allocator>
 @@ -2014,11 +2080,10 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _
 template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator>
-typename enable_if
+_EnableIf
 <
-    __is_exactly_cpp17_input_iterator<_InputIterator>::value,
+    __is_exactly_cpp17_input_iterator<_InputIterator>::value
-    void
+>
->::type
 basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
 {
     __zero();
 @@ -2041,11 +2106,10 @@ basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _Input
 template <class _CharT, class _Traits, class _Allocator>
 template <class _ForwardIterator>
-typename enable_if
+_EnableIf
 <
-    __is_cpp17_forward_iterator<_ForwardIterator>::value,
+    __is_cpp17_forward_iterator<_ForwardIterator>::value
-    void
+>
->::type
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
 @@ -2197,26 +2261,51 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t
 // assign
+template <class _CharT, class _Traits, class _Allocator>
+template <bool __is_short>
+basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
+    const value_type* __s, size_type __n) {
+  size_type __cap = __is_short ? __min_cap : __get_long_cap();
+  if (__n < __cap) {
+    pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
+    __is_short ? __set_short_size(__n) : __set_long_size(__n);
+    traits_type::copy(_VSTD::__to_address(__p), __s, __n);
+    traits_type::assign(__p[__n], value_type());
+    __invalidate_iterators_past(__n);
+  } else {
+    size_type __sz = __is_short ? __get_short_size() : __get_long_size();
+    __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s);
+  }
+  return *this;
+}
+template <class _CharT, class _Traits, class _Allocator>
+basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::__assign_external(
+    const value_type* __s, size_type __n) {
+  size_type __cap = capacity();
+  if (__cap >= __n) {
+    value_type* __p = _VSTD::__to_address(__get_pointer());
+    traits_type::move(__p, __s, __n);
+    traits_type::assign(__p[__n], value_type());
+    __set_size(__n);
+    __invalidate_iterators_past(__n);
+  } else {
+    size_type __sz = size();
+    __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
+  }
+  return *this;
+}
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
-    size_type __cap = capacity();
+    return (_LIBCPP_BUILTIN_CONSTANT_P(__n) && __n < __min_cap)
-    if (__cap >= __n)
+               ? __assign_short(__s, __n)
-    {
+               : __assign_external(__s, __n);
-        value_type* __p = _VSTD::__to_address(__get_pointer());
-        traits_type::move(__p, __s, __n);
-        traits_type::assign(__p[__n], value_type());
-        __set_size(__n);
-        __invalidate_iterators_past(__n);
-    }
-    else
-    {
-        size_type __sz = size();
-        __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
-    }
-    return *this;
 }
 template <class _CharT, class _Traits, class _Allocator>
 @@ -2263,12 +2352,19 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 {
-    if (this != &__str)
+  if (this != &__str) {
-    {
+    __copy_assign_alloc(__str);
-        __copy_assign_alloc(__str);
+    if (!__is_long()) {
-        return assign(__str.data(), __str.size());
+      if (!__str.__is_long()) {
+        __r_.first().__r = __str.__r_.first().__r;
+      } else {
+        return __assign_no_alias<true>(__str.data(), __str.size());
+      }
+    } else {
+      return __assign_no_alias<false>(__str.data(), __str.size());
     }
-    return *this;
+  }
+  return *this;
 }
 #ifndef _LIBCPP_CXX03_LANG
 @@ -2326,12 +2422,12 @@ basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
-typename enable_if
+_EnableIf
 <
      __is_exactly_cpp17_input_iterator <_InputIterator>::value
           || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
     basic_string<_CharT, _Traits, _Allocator>&
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
     const basic_string __temp(__first, __last, __alloc());
 @@ -2341,12 +2437,12 @@ basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _Input
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
-typename enable_if
+_EnableIf
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value
          && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
     basic_string<_CharT, _Traits, _Allocator>&
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
 @@ -2378,11 +2474,12 @@ basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, siz
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
-    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
+    && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
     basic_string<_CharT, _Traits, _Allocator>&
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
 {
     __self_view __sv = __t;
 @@ -2393,14 +2490,23 @@ basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __p
 }
+template <class _CharT, class _Traits, class _Allocator>
+basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) {
+  return __assign_external(__s, traits_type::length(__s));
+}
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
-    return assign(__s, traits_type::length(__s));
+    return _LIBCPP_BUILTIN_CONSTANT_P(*__s)
+               ? (traits_type::length(__s) < __min_cap
+                      ? __assign_short(__s, traits_type::length(__s))
+                      : __assign_external(__s, traits_type::length(__s)))
+               : __assign_external(__s);
 }
 // append
 template <class _CharT, class _Traits, class _Allocator>
 @@ -2565,11 +2671,11 @@ basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, siz
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-    typename enable_if
+    _EnableIf
     <
-        __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+        __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
         basic_string<_CharT, _Traits, _Allocator>&
-    >::type
+    >
 basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
 {
     __self_view __sv = __t;
 @@ -2654,12 +2760,12 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
-typename enable_if
+_EnableIf
 <
    __is_exactly_cpp17_input_iterator<_InputIterator>::value
         || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
    typename basic_string<_CharT, _Traits, _Allocator>::iterator
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
 @@ -2673,12 +2779,12 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIt
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator>
-typename enable_if
+_EnableIf
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value
         && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::iterator
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
 @@ -2743,11 +2849,11 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
-    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value  && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
     basic_string<_CharT, _Traits, _Allocator>&
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
                                                   size_type __pos2, size_type __n)
 {
 @@ -2852,8 +2958,8 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
         }
         traits_type::move(__p + __pos, __s, __n2);
 __finish:
-// __sz += __n2 - __n1; in this and the below function below can cause unsigned integer overflow,
+// __sz += __n2 - __n1; in this and the below function below can cause unsigned
-// but this is a safe operation, so we disable the check.
+// integer overflow, but this is a safe operation, so we disable the check.
         __sz += __n2 - __n1;
         __set_size(__sz);
         __invalidate_iterators_past(__sz);
 @@ -2900,11 +3006,11 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
-typename enable_if
+_EnableIf
 <
     __is_cpp17_input_iterator<_InputIterator>::value,
     basic_string<_CharT, _Traits, _Allocator>&
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
                                                    _InputIterator __j1, _InputIterator __j2)
 {
 @@ -2933,11 +3039,11 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type _
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
-    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
     basic_string<_CharT, _Traits, _Allocator>&
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
                                                    size_type __pos2, size_type __n2)
 {
 @@ -2991,15 +3097,16 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 // erase
+// 'externally instantiated' erase() implementation, called when __n != npos.
+// Does not check __pos against size()
 template <class _CharT, class _Traits, class _Allocator>
-basic_string<_CharT, _Traits, _Allocator>&
+void
-basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(
+    size_type __pos, size_type __n)
 {
-    size_type __sz = size();
-    if (__pos > __sz)
-        this->__throw_out_of_range();
     if (__n)
     {
+        size_type __sz = size();
         value_type* __p = _VSTD::__to_address(__get_pointer());
         __n = _VSTD::min(__n, __sz - __pos);
         size_type __n_move = __sz - __pos - __n;
 @@ -3010,7 +3117,19 @@ basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)
         __invalidate_iterators_past(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
-    return *this;
+}
+template <class _CharT, class _Traits, class _Allocator>
+basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
+                                                 size_type __n) {
+  if (__pos > size()) this->__throw_out_of_range();
+  if (__n == npos) {
+    __erase_to_end(__pos);
+  } else {
+    __erase_external_with_move(__pos, __n);
+  }
+  return *this;
 }
 template <class _CharT, class _Traits, class _Allocator>
 @@ -3356,11 +3475,11 @@ basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
                                                 size_type __pos) const
 {
 @@ -3414,11 +3533,11 @@ basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
                                                 size_type __pos) const
 {
 @@ -3472,11 +3591,11 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __s
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
                                                 size_type __pos) const
 {
 @@ -3530,11 +3649,11 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __st
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
                                                 size_type __pos) const
 {
 @@ -3588,11 +3707,11 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string&
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
                                                 size_type __pos) const
 {
 @@ -3647,11 +3766,11 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string&
 template<class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
                                                 size_type __pos) const
 {
 @@ -3685,11 +3804,11 @@ basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     int
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const
 {
     __self_view __sv = __t;
 @@ -3739,11 +3858,11 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
     int
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
                                                    const _Tp& __t) const
 @@ -3764,11 +3883,12 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
-typename enable_if
+_EnableIf
 <
-    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
+    && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
     int
->::type
+>
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
                                                    const _Tp& __t,
 @@ -4230,8 +4350,9 @@ _LIBCPP_FUNC_VIS wstring to_wstring(double __val);
 _LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
 template<class _CharT, class _Traits, class _Allocator>
-    const typename basic_string<_CharT, _Traits, _Allocator>::size_type
+_LIBCPP_FUNC_VIS
-                   basic_string<_CharT, _Traits, _Allocator>::npos;
+const typename basic_string<_CharT, _Traits, _Allocator>::size_type
+               basic_string<_CharT, _Traits, _Allocator>::npos;
 template <class _CharT, class _Allocator>
 struct _LIBCPP_TEMPLATE_VIS
 @@ -4283,15 +4404,25 @@ getline(basic_istream<_CharT, _Traits>&& __is,
 #endif  // _LIBCPP_CXX03_LANG
 #if _LIBCPP_STD_VER > 17
-template<class _CharT, class _Traits, class _Allocator, class _Up>
+template <class _CharT, class _Traits, class _Allocator, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v)
+    typename basic_string<_CharT, _Traits, _Allocator>::size_type
-{ __str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end()); }
+    erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
+  auto __old_size = __str.size();
+  __str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end());
+  return __old_size - __str.size();
+}
-template<class _CharT, class _Traits, class _Allocator, class _Predicate>
+template <class _CharT, class _Traits, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, _Predicate __pred)
+    typename basic_string<_CharT, _Traits, _Allocator>::size_type
-{ __str.erase(_VSTD::remove_if(__str.begin(), __str.end(), __pred), __str.end()); }
+    erase_if(basic_string<_CharT, _Traits, _Allocator>& __str,
+             _Predicate __pred) {
+  auto __old_size = __str.size();
+  __str.erase(_VSTD::remove_if(__str.begin(), __str.end(), __pred),
+              __str.end());
+  return __old_size - __str.size();
+}
 #endif
 #if _LIBCPP_DEBUG_LEVEL >= 2
 @@ -4330,9 +4461,6 @@ basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator*
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<char>)
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<wchar_t>)
 #if _LIBCPP_STD_VER > 11
 // Literal suffixes for basic_string [basic.string.literals]
 inline namespace literals

lib/libcxx/include/system_error+1

...	@@ -469,6 +469,7 @@ public:	...	@@ -469,6 +469,7 @@ public:
469	system_error(int __ev, const error_category& __ecat, const string& __what_arg);	469	system_error(int __ev, const error_category& __ecat, const string& __what_arg);
470	system_error(int __ev, const error_category& __ecat, const char* __what_arg);	470	system_error(int __ev, const error_category& __ecat, const char* __what_arg);
471	system_error(int __ev, const error_category& __ecat);	471	system_error(int __ev, const error_category& __ecat);
		472	system_error(const system_error&) _NOEXCEPT = default;
472	~system_error() _NOEXCEPT;	473	~system_error() _NOEXCEPT;
473		474
474	_LIBCPP_INLINE_VISIBILITY	475	_LIBCPP_INLINE_VISIBILITY

lib/libcxx/include/thread+13-17

 @@ -241,12 +241,19 @@ public:
 #endif
     ~thread();
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = _LIBCPP_NULL_THREAD;}
+    thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {
+        __t.__t_ = _LIBCPP_NULL_THREAD;
+    }
     _LIBCPP_INLINE_VISIBILITY
-    thread& operator=(thread&& __t) _NOEXCEPT;
+    thread& operator=(thread&& __t) _NOEXCEPT {
-#endif  // _LIBCPP_CXX03_LANG
+        if (!__libcpp_thread_isnull(&__t_))
+            terminate();
+        __t_ = __t.__t_;
+        __t.__t_ = _LIBCPP_NULL_THREAD;
+        return *this;
+    }
     _LIBCPP_INLINE_VISIBILITY
     void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
 @@ -304,17 +311,6 @@ thread::thread(_Fp&& __f, _Args&&... __args)
         __throw_system_error(__ec, "thread constructor failed");
 }
-inline
-thread&
-thread::operator=(thread&& __t) _NOEXCEPT
-{
-    if (!__libcpp_thread_isnull(&__t_))
-        terminate();
-    __t_ = __t.__t_;
-    __t.__t_ = _LIBCPP_NULL_THREAD;
-    return *this;
-}
 #else  // _LIBCPP_CXX03_LANG
 template <class _Fp>
 @@ -369,9 +365,9 @@ sleep_for(const chrono::duration<_Rep, _Period>& __d)
     {
 #if defined(_LIBCPP_COMPILER_GCC) && (__powerpc__ || __POWERPC__)
     //  GCC's long double const folding is incomplete for IBM128 long doubles.
-        _LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
-#else
         _LIBCPP_CONSTEXPR duration<long double> _Max = duration<long double>(ULLONG_MAX/1000000000ULL) ;
+#else
+        _LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
 #endif
         nanoseconds __ns;
         if (__d < _Max)

lib/libcxx/include/type_traits+391-56

...	@@ -544,6 +544,18 @@ template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp	...	@@ -544,6 +544,18 @@ template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp
544		544
545	// is_same	545	// is_same
546		546
		547	#if __has_keyword(__is_same)
		548
		549	template <class _Tp, class _Up>
		550	struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> { };
		551
		552	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		553	template <class _Tp, class _Up>
		554	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_same_v = __is_same(_Tp, _Up);
		555	#endif
		556
		557	#else
		558
547	template <class _Tp, class _Up> struct _LIBCPP_TEMPLATE_VIS is_same : public false_type {};	559	template <class _Tp, class _Up> struct _LIBCPP_TEMPLATE_VIS is_same : public false_type {};
548	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_same<_Tp, _Tp> : public true_type {};	560	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_same<_Tp, _Tp> : public true_type {};
549		561
...	@@ -553,6 +565,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_same_v	...	@@ -553,6 +565,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_same_v
553	= is_same<_Tp, _Up>::value;	565	= is_same<_Tp, _Up>::value;
554	#endif	566	#endif
555		567
		568	#endif // __is_same
		569
556	template <class _Tp, class _Up>	570	template <class _Tp, class _Up>
557	using _IsSame = _BoolConstant<	571	using _IsSame = _BoolConstant<
558	#ifdef __clang__	572	#ifdef __clang__
...	@@ -656,6 +670,18 @@ struct __two {char __lx[2];};	...	@@ -656,6 +670,18 @@ struct __two {char __lx[2];};
656		670
657	// is_const	671	// is_const
658		672
		673	#if __has_keyword(__is_const)
		674
		675	template <class _Tp>
		676	struct _LIBCPP_TEMPLATE_VIS is_const : _BoolConstant<__is_const(_Tp)> { };
		677
		678	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		679	template <class _Tp>
		680	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_const_v = __is_const(_Tp);
		681	#endif
		682
		683	#else
		684
659	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {};	685	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {};
660	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};	686	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};
661		687
...	@@ -665,8 +691,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_const_v	...	@@ -665,8 +691,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_const_v
665	= is_const<_Tp>::value;	691	= is_const<_Tp>::value;
666	#endif	692	#endif
667		693
		694	#endif // __has_keyword(__is_const)
		695
668	// is_volatile	696	// is_volatile
669		697
		698	#if __has_keyword(__is_volatile)
		699
		700	template <class _Tp>
		701	struct _LIBCPP_TEMPLATE_VIS is_volatile : _BoolConstant<__is_volatile(_Tp)> { };
		702
		703	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		704	template <class _Tp>
		705	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_volatile_v = __is_volatile(_Tp);
		706	#endif
		707
		708	#else
		709
670	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {};	710	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {};
671	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};	711	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};
672		712
...	@@ -676,37 +716,87 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_volatile_v	...	@@ -676,37 +716,87 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_volatile_v
676	= is_volatile<_Tp>::value;	716	= is_volatile<_Tp>::value;
677	#endif	717	#endif
678		718
		719	#endif // __has_keyword(__is_volatile)
		720
679	// remove_const	721	// remove_const
680		722
		723	#if __has_keyword(__remove_const)
		724
		725	template <class _Tp>
		726	struct _LIBCPP_TEMPLATE_VIS remove_const {typedef __remove_const(_Tp) type;};
		727
		728	#if _LIBCPP_STD_VER > 11
		729	template <class _Tp> using remove_const_t = __remove_const(_Tp);
		730	#endif
		731
		732	#else
		733
681	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;};	734	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;};
682	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};	735	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
683	#if _LIBCPP_STD_VER > 11	736	#if _LIBCPP_STD_VER > 11
684	template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;	737	template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
685	#endif	738	#endif
686		739
		740	#endif // __has_keyword(__remove_const)
		741
687	// remove_volatile	742	// remove_volatile
688		743
		744	#if __has_keyword(__remove_volatile)
		745
		746	template <class _Tp>
		747	struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef __remove_volatile(_Tp) type;};
		748
		749	#if _LIBCPP_STD_VER > 11
		750	template <class _Tp> using remove_volatile_t = __remove_volatile(_Tp);
		751	#endif
		752
		753	#else
		754
689	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;};	755	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;};
690	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};	756	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
691	#if _LIBCPP_STD_VER > 11	757	#if _LIBCPP_STD_VER > 11
692	template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;	758	template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
693	#endif	759	#endif
694		760
		761	#endif // __has_keyword(__remove_volatile)
		762
695	// remove_cv	763	// remove_cv
696		764
		765	#if __has_keyword(__remove_cv)
		766
		767	template <class _Tp>
		768	struct _LIBCPP_TEMPLATE_VIS remove_cv {typedef __remove_cv(_Tp) type;};
		769
		770	#if _LIBCPP_STD_VER > 11
		771	template <class _Tp> using remove_cv_t = __remove_cv(_Tp);
		772	#endif
		773
		774	#else
		775
697	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv	776	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
698	{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};	777	{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
699	#if _LIBCPP_STD_VER > 11	778	#if _LIBCPP_STD_VER > 11
700	template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;	779	template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
701	#endif	780	#endif
702		781
		782	#endif // __has_keyword(__remove_cv)
		783
703	// is_void	784	// is_void
704		785
705	template <class _Tp> struct __libcpp_is_void : public false_type {};	786	#if __has_keyword(__is_void)
706	template <> struct __libcpp_is_void<void> : public true_type {};	787
		788	template <class _Tp>
		789	struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_void(_Tp)> { };
		790
		791	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		792	template <class _Tp>
		793	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_void_v = __is_void(_Tp);
		794	#endif
		795
		796	#else
707		797
708	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void	798	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
709	: public __libcpp_is_void<typename remove_cv<_Tp>::type> {};	799	: public is_same<typename remove_cv<_Tp>::type, void> {};
710		800
711	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)	801	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
712	template <class _Tp>	802	template <class _Tp>
...	@@ -714,6 +804,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_void_v	...	@@ -714,6 +804,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_void_v
714	= is_void<_Tp>::value;	804	= is_void<_Tp>::value;
715	#endif	805	#endif
716		806
		807	#endif // __has_keyword(__is_void)
		808
717	// __is_nullptr_t	809	// __is_nullptr_t
718		810
719	template <class _Tp> struct __is_nullptr_t_impl : public false_type {};	811	template <class _Tp> struct __is_nullptr_t_impl : public false_type {};
...	@@ -735,34 +827,20 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_null_pointer_v	...	@@ -735,34 +827,20 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_null_pointer_v
735		827
736	// is_integral	828	// is_integral
737		829
738	template <class _Tp> struct __libcpp_is_integral : public false_type {};	830	#if __has_keyword(__is_integral)
739	template <> struct __libcpp_is_integral<bool> : public true_type {};	831
740	template <> struct __libcpp_is_integral<char> : public true_type {};	832	template <class _Tp>
741	template <> struct __libcpp_is_integral<signed char> : public true_type {};	833	struct _LIBCPP_TEMPLATE_VIS is_integral : _BoolConstant<__is_integral(_Tp)> { };
742	template <> struct __libcpp_is_integral<unsigned char> : public true_type {};	834
743	template <> struct __libcpp_is_integral<wchar_t> : public true_type {};	835	#if _LIBCPP_STD_VER > 14
744	#ifndef _LIBCPP_NO_HAS_CHAR8_T	836	template <class _Tp>
745	template <> struct __libcpp_is_integral<char8_t> : public true_type {};	837	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_integral_v = __is_integral(_Tp);
746	#endif
747	#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
748	template <> struct __libcpp_is_integral<char16_t> : public true_type {};
749	template <> struct __libcpp_is_integral<char32_t> : public true_type {};
750	#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
751	template <> struct __libcpp_is_integral<short> : public true_type {};
752	template <> struct __libcpp_is_integral<unsigned short> : public true_type {};
753	template <> struct __libcpp_is_integral<int> : public true_type {};
754	template <> struct __libcpp_is_integral<unsigned int> : public true_type {};
755	template <> struct __libcpp_is_integral<long> : public true_type {};
756	template <> struct __libcpp_is_integral<unsigned long> : public true_type {};
757	template <> struct __libcpp_is_integral<long long> : public true_type {};
758	template <> struct __libcpp_is_integral<unsigned long long> : public true_type {};
759	#ifndef _LIBCPP_HAS_NO_INT128
760	template <> struct __libcpp_is_integral<__int128_t> : public true_type {};
761	template <> struct __libcpp_is_integral<__uint128_t> : public true_type {};
762	#endif	838	#endif
763		839
		840	#else
		841
764	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral	842	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
765	: public __libcpp_is_integral<typename remove_cv<_Tp>::type> {};	843	: public _BoolConstant<__libcpp_is_integral<typename remove_cv<_Tp>::type>::value> {};
766		844
767	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)	845	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
768	template <class _Tp>	846	template <class _Tp>
...	@@ -770,6 +848,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_integral_v	...	@@ -770,6 +848,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_integral_v
770	= is_integral<_Tp>::value;	848	= is_integral<_Tp>::value;
771	#endif	849	#endif
772		850
		851	#endif // __has_keyword(__is_integral)
		852
773	// is_floating_point	853	// is_floating_point
774		854
775	template <class _Tp> struct __libcpp_is_floating_point : public false_type {};	855	template <class _Tp> struct __libcpp_is_floating_point : public false_type {};
...	@@ -788,6 +868,18 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_floating_point_v	...	@@ -788,6 +868,18 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_floating_point_v
788		868
789	// is_array	869	// is_array
790		870
		871	#if __has_keyword(__is_array)
		872
		873	template <class _Tp>
		874	struct _LIBCPP_TEMPLATE_VIS is_array : _BoolConstant<__is_array(_Tp)> { };
		875
		876	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		877	template <class _Tp>
		878	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v = __is_array(_Tp);
		879	#endif
		880
		881	#else
		882
791	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array	883	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array
792	: public false_type {};	884	: public false_type {};
793	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>	885	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>
...	@@ -801,8 +893,23 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v	...	@@ -801,8 +893,23 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v
801	= is_array<_Tp>::value;	893	= is_array<_Tp>::value;
802	#endif	894	#endif
803		895
		896	#endif // __has_keyword(__is_array)
		897
804	// is_pointer	898	// is_pointer
805		899
		900	// In clang 10.0.0 and earlier __is_pointer didn't work with Objective-C types.
		901	#if __has_keyword(__is_pointer) && _LIBCPP_CLANG_VER > 1000
		902
		903	template<class _Tp>
		904	struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
		905
		906	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		907	template <class _Tp>
		908	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v = __is_pointer(_Tp);
		909	#endif
		910
		911	#else // __has_keyword(__is_pointer)
		912
806	template <class _Tp> struct __libcpp_is_pointer : public false_type {};	913	template <class _Tp> struct __libcpp_is_pointer : public false_type {};
807	template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};	914	template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
808		915
...	@@ -823,8 +930,36 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v	...	@@ -823,8 +930,36 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v
823	= is_pointer<_Tp>::value;	930	= is_pointer<_Tp>::value;
824	#endif	931	#endif
825		932
		933	#endif // __has_keyword(__is_pointer)
		934
826	// is_reference	935	// is_reference
827		936
		937	#if __has_keyword(__is_lvalue_reference) && \
		938	__has_keyword(__is_rvalue_reference) && \
		939	__has_keyword(__is_reference)
		940
		941	template<class _Tp>
		942	struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { };
		943
		944	template<class _Tp>
		945	struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { };
		946
		947	template<class _Tp>
		948	struct _LIBCPP_TEMPLATE_VIS is_reference : _BoolConstant<__is_reference(_Tp)> { };
		949
		950	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		951	template <class _Tp>
		952	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_reference_v = __is_reference(_Tp);
		953
		954	template <class _Tp>
		955	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_lvalue_reference_v = __is_lvalue_reference(_Tp);
		956
		957	template <class _Tp>
		958	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_rvalue_reference_v = __is_rvalue_reference(_Tp);
		959	#endif
		960
		961	#else // __has_keyword(__is_lvalue_reference) && etc...
		962
828	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {};	963	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {};
829	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};	964	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};
830		965
...	@@ -848,6 +983,9 @@ template <class _Tp>	...	@@ -848,6 +983,9 @@ template <class _Tp>
848	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_rvalue_reference_v	983	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_rvalue_reference_v
849	= is_rvalue_reference<_Tp>::value;	984	= is_rvalue_reference<_Tp>::value;
850	#endif	985	#endif
		986
		987	#endif // __has_keyword(__is_lvalue_reference) && etc...
		988
851	// is_union	989	// is_union
852		990
853	#if __has_feature(is_union) \|\| defined(_LIBCPP_COMPILER_GCC)	991	#if __has_feature(is_union) \|\| defined(_LIBCPP_COMPILER_GCC)
...	@@ -928,6 +1066,19 @@ template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> {	...	@@ -928,6 +1066,19 @@ template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> {
928	};	1066	};
929	};	1067	};
930		1068
		1069	#if __has_keyword(__is_member_function_pointer)
		1070
		1071	template<class _Tp>
		1072	struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
		1073	: _BoolConstant<__is_member_function_pointer(_Tp)> { };
		1074
		1075	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1076	template <class _Tp>
		1077	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
		1078	= __is_member_function_pointer(_Tp);
		1079	#endif
		1080
		1081	#else // __has_keyword(__is_member_function_pointer)
931		1082
932	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer	1083	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
933	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_func > {};	1084	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_func > {};
...	@@ -938,8 +1089,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v	...	@@ -938,8 +1089,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
938	= is_member_function_pointer<_Tp>::value;	1089	= is_member_function_pointer<_Tp>::value;
939	#endif	1090	#endif
940		1091
		1092	#endif // __has_keyword(__is_member_function_pointer)
		1093
941	// is_member_pointer	1094	// is_member_pointer
942		1095
		1096	#if __has_keyword(__is_member_pointer)
		1097
		1098	template<class _Tp>
		1099	struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { };
		1100
		1101	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1102	template <class _Tp>
		1103	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v = __is_member_pointer(_Tp);
		1104	#endif
		1105
		1106	#else // __has_keyword(__is_member_pointer)
		1107
943	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer	1108	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
944	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_member > {};	1109	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_member > {};
945		1110
...	@@ -949,8 +1114,24 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v	...	@@ -949,8 +1114,24 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v
949	= is_member_pointer<_Tp>::value;	1114	= is_member_pointer<_Tp>::value;
950	#endif	1115	#endif
951		1116
		1117	#endif // __has_keyword(__is_member_pointer)
		1118
952	// is_member_object_pointer	1119	// is_member_object_pointer
953		1120
		1121	#if __has_keyword(__is_member_object_pointer)
		1122
		1123	template<class _Tp>
		1124	struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
		1125	: _BoolConstant<__is_member_object_pointer(_Tp)> { };
		1126
		1127	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1128	template <class _Tp>
		1129	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
		1130	= __is_member_object_pointer(_Tp);
		1131	#endif
		1132
		1133	#else // __has_keyword(__is_member_object_pointer)
		1134
954	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer	1135	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
955	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_obj > {};	1136	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_obj > {};
956		1137
...	@@ -960,6 +1141,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v	...	@@ -960,6 +1141,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
960	= is_member_object_pointer<_Tp>::value;	1141	= is_member_object_pointer<_Tp>::value;
961	#endif	1142	#endif
962		1143
		1144	#endif // __has_keyword(__is_member_object_pointer)
		1145
963	// is_enum	1146	// is_enum
964		1147
965	#if __has_feature(is_enum) \|\| defined(_LIBCPP_COMPILER_GCC)	1148	#if __has_feature(is_enum) \|\| defined(_LIBCPP_COMPILER_GCC)
...	@@ -967,6 +1150,11 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v	...	@@ -967,6 +1150,11 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
967	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum	1150	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
968	: public integral_constant<bool, __is_enum(_Tp)> {};	1151	: public integral_constant<bool, __is_enum(_Tp)> {};
969		1152
		1153	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1154	template <class _Tp>
		1155	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_enum_v = __is_enum(_Tp);
		1156	#endif
		1157
970	#else	1158	#else
971		1159
972	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum	1160	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
...	@@ -981,16 +1169,17 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum	...	@@ -981,16 +1169,17 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
981	!is_class<_Tp>::value &&	1169	!is_class<_Tp>::value &&
982	!is_function<_Tp>::value > {};	1170	!is_function<_Tp>::value > {};
983		1171
984	#endif
985
986	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)	1172	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
987	template <class _Tp>	1173	template <class _Tp>
988	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_enum_v	1174	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_enum_v
989	= is_enum<_Tp>::value;	1175	= is_enum<_Tp>::value;
990	#endif	1176	#endif
991		1177
		1178	#endif // __has_feature(is_enum) \|\| defined(_LIBCPP_COMPILER_GCC)
		1179
992	// is_arithmetic	1180	// is_arithmetic
993		1181
		1182
994	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic	1183	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic
995	: public integral_constant<bool, is_integral<_Tp>::value \|\|	1184	: public integral_constant<bool, is_integral<_Tp>::value \|\|
996	is_floating_point<_Tp>::value> {};	1185	is_floating_point<_Tp>::value> {};
...	@@ -1003,6 +1192,20 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_arithmetic_v	...	@@ -1003,6 +1192,20 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_arithmetic_v
1003		1192
1004	// is_fundamental	1193	// is_fundamental
1005		1194
		1195	// In clang 9 and lower, this builtin did not work for nullptr_t. Additionally, in C++03 mode,
		1196	// nullptr isn't defined by the compiler so, this builtin won't work.
		1197	#if __has_keyword(__is_fundamental) && _LIBCPP_CLANG_VER > 900 && !defined(_LIBCPP_CXX03_LANG)
		1198
		1199	template<class _Tp>
		1200	struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { };
		1201
		1202	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1203	template <class _Tp>
		1204	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_fundamental_v = __is_fundamental(_Tp);
		1205	#endif
		1206
		1207	#else // __has_keyword(__is_fundamental)
		1208
1006	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental	1209	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental
1007	: public integral_constant<bool, is_void<_Tp>::value \|\|	1210	: public integral_constant<bool, is_void<_Tp>::value \|\|
1008	__is_nullptr_t<_Tp>::value \|\|	1211	__is_nullptr_t<_Tp>::value \|\|
...	@@ -1014,13 +1217,34 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_fundamental_v	...	@@ -1014,13 +1217,34 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_fundamental_v
1014	= is_fundamental<_Tp>::value;	1217	= is_fundamental<_Tp>::value;
1015	#endif	1218	#endif
1016		1219
		1220	#endif // __has_keyword(__is_fundamental)
		1221
1017	// is_scalar	1222	// is_scalar
1018		1223
		1224	// >= 11 because in C++03 nullptr isn't actually nullptr
		1225	#if __has_keyword(__is_scalar) && !defined(_LIBCPP_CXX03_LANG)
		1226
		1227	template<class _Tp>
		1228	struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> { };
		1229
		1230	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1231	template <class _Tp>
		1232	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_scalar_v = __is_scalar(_Tp);
		1233	#endif
		1234
		1235	#else // __has_keyword(__is_scalar)
		1236
		1237	template <class _Tp> struct __is_block : false_type {};
		1238	#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
		1239	template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {};
		1240	#endif
		1241
1019	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar	1242	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar
1020	: public integral_constant<bool, is_arithmetic<_Tp>::value \|\|	1243	: public integral_constant<bool, is_arithmetic<_Tp>::value \|\|
1021	is_member_pointer<_Tp>::value \|\|	1244	is_member_pointer<_Tp>::value \|\|
1022	is_pointer<_Tp>::value \|\|	1245	is_pointer<_Tp>::value \|\|
1023	__is_nullptr_t<_Tp>::value \|\|	1246	__is_nullptr_t<_Tp>::value \|\|
		1247	__is_block<_Tp>::value \|\|
1024	is_enum<_Tp>::value > {};	1248	is_enum<_Tp>::value > {};
1025		1249
1026	template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};	1250	template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
...	@@ -1031,8 +1255,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_scalar_v	...	@@ -1031,8 +1255,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_scalar_v
1031	= is_scalar<_Tp>::value;	1255	= is_scalar<_Tp>::value;
1032	#endif	1256	#endif
1033		1257
		1258	#endif // __has_keyword(__is_scalar)
		1259
1034	// is_object	1260	// is_object
1035		1261
		1262	#if __has_keyword(__is_object)
		1263
		1264	template<class _Tp>
		1265	struct _LIBCPP_TEMPLATE_VIS is_object : _BoolConstant<__is_object(_Tp)> { };
		1266
		1267	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1268	template <class _Tp>
		1269	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_object_v = __is_object(_Tp);
		1270	#endif
		1271
		1272	#else // __has_keyword(__is_object)
		1273
1036	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object	1274	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object
1037	: public integral_constant<bool, is_scalar<_Tp>::value \|\|	1275	: public integral_constant<bool, is_scalar<_Tp>::value \|\|
1038	is_array<_Tp>::value \|\|	1276	is_array<_Tp>::value \|\|
...	@@ -1045,8 +1283,23 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_object_v	...	@@ -1045,8 +1283,23 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_object_v
1045	= is_object<_Tp>::value;	1283	= is_object<_Tp>::value;
1046	#endif	1284	#endif
1047		1285
		1286	#endif // __has_keyword(__is_object)
		1287
1048	// is_compound	1288	// is_compound
1049		1289
		1290	// >= 11 because in C++03 nullptr isn't actually nullptr
		1291	#if __has_keyword(__is_compound) && !defined(_LIBCPP_CXX03_LANG)
		1292
		1293	template<class _Tp>
		1294	struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> { };
		1295
		1296	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1297	template <class _Tp>
		1298	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_compound_v = __is_compound(_Tp);
		1299	#endif
		1300
		1301	#else // __has_keyword(__is_compound)
		1302
1050	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound	1303	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound
1051	: public integral_constant<bool, !is_fundamental<_Tp>::value> {};	1304	: public integral_constant<bool, !is_fundamental<_Tp>::value> {};
1052		1305
...	@@ -1056,6 +1309,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_compound_v	...	@@ -1056,6 +1309,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_compound_v
1056	= is_compound<_Tp>::value;	1309	= is_compound<_Tp>::value;
1057	#endif	1310	#endif
1058		1311
		1312	#endif // __has_keyword(__is_compound)
1059		1313
1060	// __is_referenceable [defns.referenceable]	1314	// __is_referenceable [defns.referenceable]
1061		1315
...	@@ -1100,6 +1354,13 @@ template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;	...	@@ -1100,6 +1354,13 @@ template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
1100		1354
1101	// remove_reference	1355	// remove_reference
1102		1356
		1357	#if __has_keyword(__remove_reference)
		1358
		1359	template<class _Tp>
		1360	struct _LIBCPP_TEMPLATE_VIS remove_reference { typedef __remove_reference(_Tp) type; };
		1361
		1362	#else // __has_keyword(__remove_reference)
		1363
1103	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};	1364	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
1104	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};	1365	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
1105	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};	1366	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
...	@@ -1108,6 +1369,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typede	...	@@ -1108,6 +1369,8 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typede
1108	template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;	1369	template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
1109	#endif	1370	#endif
1110		1371
		1372	#endif // __has_keyword(__remove_reference)
		1373
1111	// add_lvalue_reference	1374	// add_lvalue_reference
1112		1375
1113	template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };	1376	template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
...	@@ -1215,6 +1478,19 @@ template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;	...	@@ -1215,6 +1478,19 @@ template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;
1215		1478
1216	// is_signed	1479	// is_signed
1217		1480
		1481	// In clang 9 and earlier, this builtin did not work for floating points or enums
		1482	#if __has_keyword(__is_signed) && _LIBCPP_CLANG_VER > 900
		1483
		1484	template<class _Tp>
		1485	struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> { };
		1486
		1487	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1488	template <class _Tp>
		1489	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v = __is_signed(_Tp);
		1490	#endif
		1491
		1492	#else // __has_keyword(__is_signed)
		1493
1218	template <class _Tp, bool = is_integral<_Tp>::value>	1494	template <class _Tp, bool = is_integral<_Tp>::value>
1219	struct __libcpp_is_signed_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(-1) < _Tp(0)) {};	1495	struct __libcpp_is_signed_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(-1) < _Tp(0)) {};
1220		1496
...	@@ -1234,8 +1510,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v	...	@@ -1234,8 +1510,22 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v
1234	= is_signed<_Tp>::value;	1510	= is_signed<_Tp>::value;
1235	#endif	1511	#endif
1236		1512
		1513	#endif // __has_keyword(__is_signed)
		1514
1237	// is_unsigned	1515	// is_unsigned
1238		1516
		1517	#if __has_keyword(__is_unsigned)
		1518
		1519	template<class _Tp>
		1520	struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { };
		1521
		1522	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1523	template <class _Tp>
		1524	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_unsigned_v = __is_unsigned(_Tp);
		1525	#endif
		1526
		1527	#else // __has_keyword(__is_unsigned)
		1528
1239	template <class _Tp, bool = is_integral<_Tp>::value>	1529	template <class _Tp, bool = is_integral<_Tp>::value>
1240	struct __libcpp_is_unsigned_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(0) < _Tp(-1)) {};	1530	struct __libcpp_is_unsigned_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(0) < _Tp(-1)) {};
1241		1531
...	@@ -1255,6 +1545,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_unsigned_v	...	@@ -1255,6 +1545,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_unsigned_v
1255	= is_unsigned<_Tp>::value;	1545	= is_unsigned<_Tp>::value;
1256	#endif	1546	#endif
1257		1547
		1548	#endif // __has_keyword(__is_unsigned)
		1549
1258	// rank	1550	// rank
1259		1551
1260	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank	1552	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank
...	@@ -1272,6 +1564,19 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t rank_v	...	@@ -1272,6 +1564,19 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t rank_v
1272		1564
1273	// extent	1565	// extent
1274		1566
		1567	#if __has_keyword(__array_extent)
		1568
		1569	template<class _Tp, size_t _Dim = 0>
		1570	struct _LIBCPP_TEMPLATE_VIS extent
		1571	: integral_constant<size_t, __array_extent(_Tp, _Dim)> { };
		1572
		1573	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		1574	template <class _Tp, unsigned _Ip = 0>
		1575	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t extent_v = __array_extent(_Tp, _Ip);
		1576	#endif
		1577
		1578	#else // __has_keyword(__array_extent)
		1579
1275	template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent	1580	template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent
1276	: public integral_constant<size_t, 0> {};	1581	: public integral_constant<size_t, 0> {};
1277	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>	1582	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>
...	@@ -1289,6 +1594,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t extent_v	...	@@ -1289,6 +1594,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t extent_v
1289	= extent<_Tp, _Ip>::value;	1594	= extent<_Tp, _Ip>::value;
1290	#endif	1595	#endif
1291		1596
		1597	#endif // __has_keyword(__array_extent)
		1598
1292	// remove_extent	1599	// remove_extent
1293		1600
1294	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent	1601	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent
...	@@ -2041,9 +2348,33 @@ struct _LIBCPP_TEMPLATE_VIS make_unsigned	...	@@ -2041,9 +2348,33 @@ struct _LIBCPP_TEMPLATE_VIS make_unsigned
2041	template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;	2348	template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
2042	#endif	2349	#endif
2043		2350
		2351	#if _LIBCPP_STD_VER > 14
		2352	template <class...> using void_t = void;
		2353	#endif
		2354
		2355	#if _LIBCPP_STD_VER > 17
		2356	// Let COND_RES(X, Y) be:
		2357	template <class _Tp, class _Up>
		2358	using __cond_type = decltype(false ? _VSTD::declval<_Tp>() : _VSTD::declval<_Up>());
		2359
		2360	template <class _Tp, class _Up, class = void>
		2361	struct __common_type3 {};
		2362
		2363	// sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
		2364	template <class _Tp, class _Up>
		2365	struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>>
		2366	{
		2367	using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
		2368	};
		2369
		2370	template <class _Tp, class _Up, class = void>
		2371	struct __common_type2_imp : __common_type3<_Tp, _Up> {};
		2372	#else
2044	template <class _Tp, class _Up, class = void>	2373	template <class _Tp, class _Up, class = void>
2045	struct __common_type2_imp {};	2374	struct __common_type2_imp {};
		2375	#endif
2046		2376
		2377	// sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..."
2047	template <class _Tp, class _Up>	2378	template <class _Tp, class _Up>
2048	struct __common_type2_imp<_Tp, _Up,	2379	struct __common_type2_imp<_Tp, _Up,
2049	typename __void_t<decltype(	2380	typename __void_t<decltype(
...	@@ -2107,6 +2438,7 @@ struct _LIBCPP_TEMPLATE_VIS common_type<_Tp>	...	@@ -2107,6 +2438,7 @@ struct _LIBCPP_TEMPLATE_VIS common_type<_Tp>
2107		2438
2108	// bullet 3 - sizeof...(Tp) == 2	2439	// bullet 3 - sizeof...(Tp) == 2
2109		2440
		2441	// sub-bullet 1 - "If is_same_v<T1, D1> is false or ..."
2110	template <class _Tp, class _Up>	2442	template <class _Tp, class _Up>
2111	struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up>	2443	struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up>
2112	: conditional<	2444	: conditional<
...	@@ -2134,6 +2466,18 @@ template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type	...	@@ -2134,6 +2466,18 @@ template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type
2134		2466
2135	template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };	2467	template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
2136		2468
		2469	#if __has_keyword(__is_assignable)
		2470
		2471	template<class _Tp, class _Up>
		2472	struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { };
		2473
		2474	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		2475	template <class _Tp, class _Arg>
		2476	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_assignable_v = __is_assignable(_Tp, _Arg);
		2477	#endif
		2478
		2479	#else // __has_keyword(__is_assignable)
		2480
2137	template <class _Tp, class _Arg>	2481	template <class _Tp, class _Arg>
2138	typename __select_2nd<decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>())), true_type>::type	2482	typename __select_2nd<decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>())), true_type>::type
2139	__is_assignable_test(int);	2483	__is_assignable_test(int);
...	@@ -2162,6 +2506,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_assignable_v	...	@@ -2162,6 +2506,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_assignable_v
2162	= is_assignable<_Tp, _Arg>::value;	2506	= is_assignable<_Tp, _Arg>::value;
2163	#endif	2507	#endif
2164		2508
		2509	#endif // __has_keyword(__is_assignable)
		2510
2165	// is_copy_assignable	2511	// is_copy_assignable
2166		2512
2167	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_copy_assignable	2513	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
...	@@ -2188,6 +2534,18 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_move_assignable_v	...	@@ -2188,6 +2534,18 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_move_assignable_v
2188		2534
2189	// is_destructible	2535	// is_destructible
2190		2536
		2537	#if __has_keyword(__is_destructible)
		2538
		2539	template<class _Tp>
		2540	struct _LIBCPP_TEMPLATE_VIS is_destructible : _BoolConstant<__is_destructible(_Tp)> { };
		2541
		2542	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
		2543	template <class _Tp>
		2544	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_destructible_v = __is_destructible(_Tp);
		2545	#endif
		2546
		2547	#else // __has_keyword(__is_destructible)
		2548
2191	// if it's a reference, return true	2549	// if it's a reference, return true
2192	// if it's a function, return false	2550	// if it's a function, return false
2193	// if it's void, return false	2551	// if it's void, return false
...	@@ -2250,6 +2608,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_destructible_v	...	@@ -2250,6 +2608,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_destructible_v
2250	= is_destructible<_Tp>::value;	2608	= is_destructible<_Tp>::value;
2251	#endif	2609	#endif
2252		2610
		2611	#endif // __has_keyword(__is_destructible)
		2612
2253	// move	2613	// move
2254		2614
2255	template <class _Tp>	2615	template <class _Tp>
...	@@ -3879,7 +4239,6 @@ struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {};	...	@@ -3879,7 +4239,6 @@ struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {};
3879	template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;	4239	template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
3880	#endif	4240	#endif
3881		4241
3882
3883	template <class _Tp, bool = is_enum<_Tp>::value>	4242	template <class _Tp, bool = is_enum<_Tp>::value>
3884	struct __sfinae_underlying_type	4243	struct __sfinae_underlying_type
3885	{	4244	{
...	@@ -3962,8 +4321,6 @@ struct __has_operator_addressof	...	@@ -3962,8 +4321,6 @@ struct __has_operator_addressof
3962		4321
3963	#if _LIBCPP_STD_VER > 14	4322	#if _LIBCPP_STD_VER > 14
3964		4323
3965	template <class...> using void_t = void;
3966
3967	template <class... _Args>	4324	template <class... _Args>
3968	struct conjunction : _And<_Args...> {};	4325	struct conjunction : _And<_Args...> {};
3969	template<class... _Args>	4326	template<class... _Args>
...	@@ -4040,29 +4397,7 @@ _LIBCPP_END_NAMESPACE_STD	...	@@ -4040,29 +4397,7 @@ _LIBCPP_END_NAMESPACE_STD
4040	// std::byte	4397	// std::byte
4041	namespace std // purposefully not versioned	4398	namespace std // purposefully not versioned
4042	{	4399	{
4043	template <class _Integer>	4400
4044	constexpr typename enable_if<is_integral_v<_Integer>, byte>::type &
4045	operator<<=(byte& __lhs, _Integer __shift) noexcept
4046	{ return __lhs = __lhs << __shift; }
4047
4048	template <class _Integer>
4049	constexpr typename enable_if<is_integral_v<_Integer>, byte>::type
4050	operator<< (byte __lhs, _Integer __shift) noexcept
4051	{ return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) << __shift)); }
4052
4053	template <class _Integer>
4054	constexpr typename enable_if<is_integral_v<_Integer>, byte>::type &
4055	operator>>=(byte& __lhs, _Integer __shift) noexcept
4056	{ return __lhs = __lhs >> __shift; }
4057
4058	template <class _Integer>
4059	constexpr typename enable_if<is_integral_v<_Integer>, byte>::type
4060	operator>> (byte __lhs, _Integer __shift) noexcept
4061	{ return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) >> __shift)); }
4062
4063	template <class _Integer>
4064	constexpr typename enable_if<is_integral_v<_Integer>, _Integer>::type
4065	to_integer(byte __b) noexcept { return static_cast<_Integer>(__b); }
4066		4401
4067	}	4402	}
4068	#endif	4403	#endif

lib/libcxx/include/typeinfo+9-4

...	@@ -60,6 +60,7 @@ public:	...	@@ -60,6 +60,7 @@ public:
60	#include <exception>	60	#include <exception>
61	#include <cstddef>	61	#include <cstddef>
62	#include <cstdint>	62	#include <cstdint>
		63	#include <type_traits>
63	#ifdef _LIBCPP_NO_EXCEPTIONS	64	#ifdef _LIBCPP_NO_EXCEPTIONS
64	#include <cstdlib>	65	#include <cstdlib>
65	#endif	66	#endif
...	@@ -120,6 +121,7 @@ public:	...	@@ -120,6 +121,7 @@ public:
120	// ========================================================================== //	121	// ========================================================================== //
121	// ------------------------------------------------------------------------- //	122	// ------------------------------------------------------------------------- //
122	// Unique	123	// Unique
		124	// (_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION = 1)
123	// ------------------------------------------------------------------------- //	125	// ------------------------------------------------------------------------- //
124	// This implementation of type_info assumes a unique copy of the RTTI for a	126	// This implementation of type_info assumes a unique copy of the RTTI for a
125	// given type inside a program. This is a valid assumption when abiding to	127	// given type inside a program. This is a valid assumption when abiding to
...	@@ -129,6 +131,7 @@ public:	...	@@ -129,6 +131,7 @@ public:
129	// a deep string comparison.	131	// a deep string comparison.
130	// -------------------------------------------------------------------------- //	132	// -------------------------------------------------------------------------- //
131	// NonUnique	133	// NonUnique
		134	// (_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION = 2)
132	// -------------------------------------------------------------------------- //	135	// -------------------------------------------------------------------------- //
133	// This implementation of type_info does not assume there is always a unique	136	// This implementation of type_info does not assume there is always a unique
134	// copy of the RTTI for a given type inside a program. For various reasons	137	// copy of the RTTI for a given type inside a program. For various reasons
...	@@ -138,6 +141,7 @@ public:	...	@@ -138,6 +141,7 @@ public:
138	// comparison is equal.	141	// comparison is equal.
139	// -------------------------------------------------------------------------- //	142	// -------------------------------------------------------------------------- //
140	// NonUniqueARMRTTIBit	143	// NonUniqueARMRTTIBit
		144	// (selected on ARM64 regardless of _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION)
141	// -------------------------------------------------------------------------- //	145	// -------------------------------------------------------------------------- //
142	// This implementation of type_info does not assume always a unique copy of	146	// This implementation of type_info does not assume always a unique copy of
143	// the RTTI for a given type inside a program. It packs the pointer to the	147	// the RTTI for a given type inside a program. It packs the pointer to the
...	@@ -255,12 +259,12 @@ struct __type_info_implementations {	...	@@ -255,12 +259,12 @@ struct __type_info_implementations {
255	typedef	259	typedef
256	#if defined(__APPLE__) && defined(__LP64__) && !defined(__x86_64__)	260	#if defined(__APPLE__) && defined(__LP64__) && !defined(__x86_64__)
257	__non_unique_arm_rtti_bit_impl	261	__non_unique_arm_rtti_bit_impl
258	#elif _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT == 0	262	#elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 1
259	__non_unique_impl
260	#elif _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT == 1
261	__unique_impl	263	__unique_impl
		264	#elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 2
		265	__non_unique_impl
262	#else	266	#else
263	# error invalid configuration for _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT	267	# error invalid configuration for _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
264	#endif	268	#endif
265	__impl;	269	__impl;
266	};	270	};
...	@@ -318,6 +322,7 @@ class _LIBCPP_EXCEPTION_ABI bad_cast	...	@@ -318,6 +322,7 @@ class _LIBCPP_EXCEPTION_ABI bad_cast
318	{	322	{
319	public:	323	public:
320	bad_cast() _NOEXCEPT;	324	bad_cast() _NOEXCEPT;
		325	bad_cast(const bad_cast&) _NOEXCEPT = default;
321	virtual ~bad_cast() _NOEXCEPT;	326	virtual ~bad_cast() _NOEXCEPT;
322	virtual const char* what() const _NOEXCEPT;	327	virtual const char* what() const _NOEXCEPT;
323	};	328	};

lib/libcxx/include/unordered_map+18-8

 @@ -386,10 +386,12 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
               noexcept(noexcept(x.swap(y)));
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
+    typename unordered_map<K, T, H, P, A>::size_type
+    erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);       // C++20
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
+    typename unordered_multimap<K, T, H, P, A>::size_type
+    erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);  // C++20
 template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
 @@ -1704,10 +1706,14 @@ swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 }
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+    typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 @@ -2402,10 +2408,14 @@ swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 }
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+    typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>

lib/libcxx/include/unordered_set+18-8

 @@ -341,10 +341,12 @@ template <class Value, class Hash, class Pred, class Alloc>
               noexcept(noexcept(x.swap(y)));
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
+    typename unordered_set<K, T, H, P, A>::size_type
+    erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
+    typename unordered_multiset<K, T, H, P, A>::size_type
+    erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
 template <class Value, class Hash, class Pred, class Alloc>
 @@ -1006,10 +1008,14 @@ swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
 }
 #if _LIBCPP_STD_VER > 17
-template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Value, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+    typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 @@ -1637,10 +1643,14 @@ swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
 }
 #if _LIBCPP_STD_VER > 17
-template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Value, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+    typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type
-{ __libcpp_erase_if_container(__c, __pred); }
+    erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 template <class _Value, class _Hash, class _Pred, class _Alloc>

lib/libcxx/include/variant+14-8

 @@ -1063,18 +1063,24 @@ public:
       }
       __impl __tmp(_VSTD::move(*__rhs));
 #ifndef _LIBCPP_NO_EXCEPTIONS
-      // EXTENSION: When the move construction of `__lhs` into `__rhs` throws
+      if constexpr (__all<is_nothrow_move_constructible_v<_Types>...>::value) {
-      // and `__tmp` is nothrow move constructible then we move `__tmp` back
-      // into `__rhs` and provide the strong exception safety guarantee.
-      try {
         this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
-      } catch (...) {
+      } else {
-        if (__tmp.__move_nothrow()) {
+        // EXTENSION: When the move construction of `__lhs` into `__rhs` throws
-          this->__generic_construct(*__rhs, _VSTD::move(__tmp));
+        // and `__tmp` is nothrow move constructible then we move `__tmp` back
+        // into `__rhs` and provide the strong exception safety guarantee.
+        try {
+          this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
+        } catch (...) {
+          if (__tmp.__move_nothrow()) {
+            this->__generic_construct(*__rhs, _VSTD::move(__tmp));
+          }
+          throw;
         }
-        throw;
       }
 #else
+      // this isn't consolidated with the `if constexpr` branch above due to
+      // `throw` being ill-formed with exceptions disabled even when discarded.
       this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
 #endif
       this->__generic_construct(*__lhs, _VSTD::move(__tmp));

lib/libcxx/include/vector+27-16

 @@ -261,9 +261,11 @@ void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 template <class T, class Allocator, class U>
-    void erase(vector<T, Allocator>& c, const U& value);       // C++20
+typename vector<T, Allocator>::size_type
+erase(vector<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
+typename vector<T, Allocator>::size_type
+erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
 }  // std
 @@ -1041,8 +1043,9 @@ void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
 {
     _ConstructTransaction __tx(*this, __n);
-    for (; __tx.__pos_ != __tx.__new_end_; ++__tx.__pos_) {
+    const_pointer __new_end = __tx.__new_end_;
-      __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_));
+    for (pointer __pos = __tx.__pos_; __pos != __new_end; ++__pos, __tx.__pos_ = __pos) {
+        __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos));
     }
 }
 @@ -1058,8 +1061,9 @@ void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
     _ConstructTransaction __tx(*this, __n);
-    for (; __tx.__pos_ != __tx.__new_end_; ++__tx.__pos_) {
+    const_pointer __new_end = __tx.__new_end_;
-        __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_), __x);
+    for (pointer __pos = __tx.__pos_; __pos != __new_end; ++__pos, __tx.__pos_ = __pos) {
+        __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos), __x);
     }
 }
 @@ -1751,9 +1755,10 @@ vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointe
     {
       pointer __i = __from_s + __n;
       _ConstructTransaction __tx(*this, __from_e - __i);
-      for (; __i < __from_e; ++__i, ++__tx.__pos_) {
+      for (pointer __pos = __tx.__pos_; __i < __from_e;
+           ++__i, ++__pos, __tx.__pos_ = __pos) {
           __alloc_traits::construct(this->__alloc(),
-                                    _VSTD::__to_address(__tx.__pos_),
+                                    _VSTD::__to_address(__pos),
                                     _VSTD::move(*__i));
       }
     }
 @@ -1956,8 +1961,8 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __firs
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
     __p = _VSTD::rotate(__p, __old_last, this->__end_);
-    insert(__make_iter(__p), make_move_iterator(__v.begin()),
+    insert(__make_iter(__p), _VSTD::make_move_iterator(__v.begin()),
-                                    make_move_iterator(__v.end()));
+                             _VSTD::make_move_iterator(__v.end()));
     return begin() + __off;
 }
 @@ -3389,14 +3394,20 @@ swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
-void erase(vector<_Tp, _Allocator>& __c, const _Up& __v)
+erase(vector<_Tp, _Allocator>& __c, const _Up& __v) {
-{ __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end()); }
+  auto __old_size = __c.size();
+  __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end());
+  return __old_size - __c.size();
+}
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
-void erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred)
+erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) {
-{ __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
+  auto __old_size = __c.size();
+  __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
+  return __old_size - __c.size();
+}
 #endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/version+16-5

 @@ -21,7 +21,8 @@ __cpp_lib_allocator_traits_is_always_equal              201411L <memory> <scoped
                                                                 <unordered_map> <unordered_set>
 __cpp_lib_any                                           201606L <any>
 __cpp_lib_apply                                         201603L <tuple>
-__cpp_lib_array_constexpr                               201603L <iterator> <array>
+__cpp_lib_array_constexpr                               201811L <iterator> <array>
+                                                        201603L // C++17
 __cpp_lib_as_const                                      201510L <utility>
 __cpp_lib_atomic_is_always_lock_free                    201603L <atomic>
 __cpp_lib_atomic_ref                                    201806L <atomic>
 @@ -44,7 +45,7 @@ __cpp_lib_constexpr_swap_algorithms                     201806L <algorithm>
 __cpp_lib_destroying_delete                             201806L <new>
 __cpp_lib_enable_shared_from_this                       201603L <memory>
 __cpp_lib_endian                                        201907L <bit>
-__cpp_lib_erase_if                                      201811L <string> <deque> <forward_list>
+__cpp_lib_erase_if                                      202002L <string> <deque> <forward_list>
                                                                 <list> <vector> <map>
                                                                 <set> <unordered_map> <unordered_set>
 __cpp_lib_exchange_function                             201304L <utility>
 @@ -74,6 +75,7 @@ __cpp_lib_make_from_tuple                               201606L <tuple>
 __cpp_lib_make_reverse_iterator                         201402L <iterator>
 __cpp_lib_make_unique                                   201304L <memory>
 __cpp_lib_map_try_emplace                               201411L <map>
+__cpp_lib_math_constants                                201907L <numbers>
 __cpp_lib_math_special_functions                        201603L <cmath>
 __cpp_lib_memory_resource                               201603L <memory_resource>
 __cpp_lib_node_extract                                  201606L <map> <set> <unordered_map>
 @@ -98,9 +100,11 @@ __cpp_lib_shared_mutex                                  201505L <shared_mutex>
 __cpp_lib_shared_ptr_arrays                             201611L <memory>
 __cpp_lib_shared_ptr_weak_type                          201606L <memory>
 __cpp_lib_shared_timed_mutex                            201402L <shared_mutex>
+__cpp_lib_span                                          202002L <span>
 __cpp_lib_string_udls                                   201304L <string>
 __cpp_lib_string_view                                   201606L <string> <string_view>
 __cpp_lib_three_way_comparison                          201711L <compare>
+__cpp_lib_to_array                                      201907L <array>
 __cpp_lib_to_chars                                      201611L <utility>
 __cpp_lib_transformation_trait_aliases                  201304L <type_traits>
 __cpp_lib_transparent_operators                         201510L <functional>
 @@ -167,7 +171,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 // # define __cpp_lib_execution                            201603L
 # define __cpp_lib_filesystem                           201703L
 # define __cpp_lib_gcd_lcm                              201606L
-# define __cpp_lib_hardware_interference_size           201703L
+// # define __cpp_lib_hardware_interference_size           201703L
 # if defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
 #   define __cpp_lib_has_unique_object_representations  201606L
 # endif
 @@ -210,6 +214,8 @@ __cpp_lib_void_t                                        201411L <type_traits>
 #endif
 #if _LIBCPP_STD_VER > 17
+# undef  __cpp_lib_array_constexpr
+# define __cpp_lib_array_constexpr                      201811L
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_atomic_ref                         201806L
 # endif
 @@ -225,15 +231,20 @@ __cpp_lib_void_t                                        201411L <type_traits>
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
-# define __cpp_lib_erase_if                             201811L
+# define __cpp_lib_erase_if                             202002L
 // # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_interpolate                          201902L
 # if !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
 #   define __cpp_lib_is_constant_evaluated              201811L
 # endif
-// # define __cpp_lib_list_remove_return_type              201806L
+# define __cpp_lib_list_remove_return_type              201806L
+# if defined(__cpp_concepts) && __cpp_concepts >= 201811L
+#   define __cpp_lib_math_constants                     201907L
+# endif
 // # define __cpp_lib_ranges                               201811L
+# define __cpp_lib_span                                 202002L
 // # define __cpp_lib_three_way_comparison                 201711L
+# define __cpp_lib_to_array                             201907L
 #endif
 #endif // _LIBCPP_VERSIONH

lib/libcxx/include/wchar.h+1

...	@@ -106,6 +106,7 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,	...	@@ -106,6 +106,7 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
106	*/	106	*/
107		107
108	#include <__config>	108	#include <__config>
		109	#include <stddef.h>
109		110
110	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	111	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
111	#pragma GCC system_header	112	#pragma GCC system_header

lib/libcxx/src/algorithm.cpp-48

...	@@ -7,13 +7,6 @@	...	@@ -7,13 +7,6 @@
7	//===----------------------------------------------------------------------===//	7	//===----------------------------------------------------------------------===//
8		8
9	#include "algorithm"	9	#include "algorithm"
10	#include "random"
11	#ifndef _LIBCPP_HAS_NO_THREADS
12	#include "mutex"
13	#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
14	#pragma comment(lib, "pthread")
15	#endif
16	#endif
17		10
18	_LIBCPP_BEGIN_NAMESPACE_STD	11	_LIBCPP_BEGIN_NAMESPACE_STD
19		12
...	@@ -51,45 +44,4 @@ template bool __insertion_sort_incomplete<__less<long double>&, long double*>(lo	...	@@ -51,45 +44,4 @@ template bool __insertion_sort_incomplete<__less<long double>&, long double*>(lo
51		44
52	template unsigned __sort5<__less<long double>&, long double>(long double, long double, long double, long double, long double, __less<long double>&);	45	template unsigned __sort5<__less<long double>&, long double>(long double, long double, long double, long double, long double, __less<long double>&);
53		46
54	#ifndef _LIBCPP_HAS_NO_THREADS
55	_LIBCPP_SAFE_STATIC static __libcpp_mutex_t __rs_mut = _LIBCPP_MUTEX_INITIALIZER;
56	#endif
57	unsigned __rs_default::__c_ = 0;
58
59	__rs_default::__rs_default()
60	{
61	#ifndef _LIBCPP_HAS_NO_THREADS
62	__libcpp_mutex_lock(&__rs_mut);
63	#endif
64	__c_ = 1;
65	}
66
67	__rs_default::__rs_default(const __rs_default&)
68	{
69	++__c_;
70	}
71
72	__rs_default::~__rs_default()
73	{
74	#ifndef _LIBCPP_HAS_NO_THREADS
75	if (--__c_ == 0)
76	__libcpp_mutex_unlock(&__rs_mut);
77	#else
78	--__c_;
79	#endif
80	}
81
82	__rs_default::result_type
83	__rs_default::operator()()
84	{
85	static mt19937 __rs_g;
86	return __rs_g();
87	}
88
89	__rs_default
90	__rs_get()
91	{
92	return __rs_default();
93	}
94
95	_LIBCPP_END_NAMESPACE_STD	47	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/src/atomic.cpp created+189

...	@@ -0,0 +1,189 @@
1	//===------------------------- atomic.cpp ---------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#include <__config>
10	#ifndef _LIBCPP_HAS_NO_THREADS
11
12	#include <climits>
13	#include <atomic>
14	#include <functional>
15
16	#include <iostream>
17
18	#ifdef __linux__
19
20	#include <unistd.h>
21	#include <linux/futex.h>
22	#include <sys/syscall.h>
23
24	#else // <- Add other operating systems here
25
26	// Baseline needs no new headers
27
28	#endif
29
30	_LIBCPP_BEGIN_NAMESPACE_STD
31
32	#ifdef __linux__
33
34	static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
35	__cxx_contention_t __val)
36	{
37	static constexpr timespec __timeout = { 2, 0 };
38	syscall(SYS_futex, __ptr, FUTEX_WAIT_PRIVATE, __val, &__timeout, 0, 0);
39	}
40
41	static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr,
42	bool __notify_one)
43	{
44	syscall(SYS_futex, __ptr, FUTEX_WAKE_PRIVATE, __notify_one ? 1 : INT_MAX, 0, 0, 0);
45	}
46
47	#elif defined(__APPLE__) && defined(_LIBCPP_USE_ULOCK)
48
49	extern "C" int __ulock_wait(uint32_t operation, void *addr, uint64_t value,
50	uint32_t timeout); /* timeout is specified in microseconds */
51	extern "C" int __ulock_wake(uint32_t operation, void *addr, uint64_t wake_value);
52
53	#define UL_COMPARE_AND_WAIT 1
54	#define ULF_WAKE_ALL 0x00000100
55
56	static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
57	__cxx_contention_t __val)
58	{
59	__ulock_wait(UL_COMPARE_AND_WAIT,
60	const_cast<__cxx_atomic_contention_t*>(__ptr), __val, 0);
61	}
62
63	static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr,
64	bool __notify_one)
65	{
66	__ulock_wake(UL_COMPARE_AND_WAIT \| (__notify_one ? 0 : ULF_WAKE_ALL),
67	const_cast<__cxx_atomic_contention_t*>(__ptr), 0);
68	}
69
70	#else // <- Add other operating systems here
71
72	// Baseline is just a timed backoff
73
74	static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
75	__cxx_contention_t __val)
76	{
77	__libcpp_thread_poll_with_backoff([=]() -> bool {
78	return !__cxx_nonatomic_compare_equal(__cxx_atomic_load(__ptr, memory_order_relaxed), __val);
79	}, __libcpp_timed_backoff_policy());
80	}
81
82	static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile*, bool) { }
83
84	#endif // __linux__
85
86	static constexpr size_t __libcpp_contention_table_size = (1 << 8); /* < there's no magic in this number */
87
88	struct alignas(64) /* aim to avoid false sharing */ __libcpp_contention_table_entry
89	{
90	__cxx_atomic_contention_t __contention_state;
91	__cxx_atomic_contention_t __platform_state;
92	inline constexpr __libcpp_contention_table_entry() :
93	__contention_state(0), __platform_state(0) { }
94	};
95
96	static __libcpp_contention_table_entry __libcpp_contention_table[ __libcpp_contention_table_size ];
97
98	static hash<void const volatile*> __libcpp_contention_hasher;
99
100	static __libcpp_contention_table_entry* __libcpp_contention_state(void const volatile * p)
101	{
102	return &__libcpp_contention_table[__libcpp_contention_hasher(p) & (__libcpp_contention_table_size - 1)];
103	}
104
105	/* Given an atomic to track contention and an atomic to actually wait on, which may be
106	the same atomic, we try to detect contention to avoid spuriously calling the platform. */
107
108	static void __libcpp_contention_notify(__cxx_atomic_contention_t volatile* __contention_state,
109	__cxx_atomic_contention_t const volatile* __platform_state,
110	bool __notify_one)
111	{
112	if(0 != __cxx_atomic_load(__contention_state, memory_order_seq_cst))
113	// We only call 'wake' if we consumed a contention bit here.
114	__libcpp_platform_wake_by_address(__platform_state, __notify_one);
115	}
116	static __cxx_contention_t __libcpp_contention_monitor_for_wait(__cxx_atomic_contention_t volatile* __contention_state,
117	__cxx_atomic_contention_t const volatile* __platform_state)
118	{
119	// We will monitor this value.
120	return __cxx_atomic_load(__platform_state, memory_order_acquire);
121	}
122	static void __libcpp_contention_wait(__cxx_atomic_contention_t volatile* __contention_state,
123	__cxx_atomic_contention_t const volatile* __platform_state,
124	__cxx_contention_t __old_value)
125	{
126	__cxx_atomic_fetch_add(__contention_state, __cxx_contention_t(1), memory_order_seq_cst);
127	// We sleep as long as the monitored value hasn't changed.
128	__libcpp_platform_wait_on_address(__platform_state, __old_value);
129	__cxx_atomic_fetch_sub(__contention_state, __cxx_contention_t(1), memory_order_release);
130	}
131
132	/* When the incoming atomic is the wrong size for the platform wait size, need to
133	launder the value sequence through an atomic from our table. */
134
135	static void __libcpp_atomic_notify(void const volatile* __location)
136	{
137	auto const __entry = __libcpp_contention_state(__location);
138	// The value sequence laundering happens on the next line below.
139	__cxx_atomic_fetch_add(&__entry->__platform_state, __cxx_contention_t(1), memory_order_release);
140	__libcpp_contention_notify(&__entry->__contention_state,
141	&__entry->__platform_state,
142	false /* when laundering, we can't handle notify_one */);
143	}
144	_LIBCPP_EXPORTED_FROM_ABI
145	void __cxx_atomic_notify_one(void const volatile* __location)
146	{ __libcpp_atomic_notify(__location); }
147	_LIBCPP_EXPORTED_FROM_ABI
148	void __cxx_atomic_notify_all(void const volatile* __location)
149	{ __libcpp_atomic_notify(__location); }
150	_LIBCPP_EXPORTED_FROM_ABI
151	__cxx_contention_t __libcpp_atomic_monitor(void const volatile* __location)
152	{
153	auto const __entry = __libcpp_contention_state(__location);
154	return __libcpp_contention_monitor_for_wait(&__entry->__contention_state, &__entry->__platform_state);
155	}
156	_LIBCPP_EXPORTED_FROM_ABI
157	void __libcpp_atomic_wait(void const volatile* __location, __cxx_contention_t __old_value)
158	{
159	auto const __entry = __libcpp_contention_state(__location);
160	__libcpp_contention_wait(&__entry->__contention_state, &__entry->__platform_state, __old_value);
161	}
162
163	/* When the incoming atomic happens to be the platform wait size, we still need to use the
164	table for the contention detection, but we can use the atomic directly for the wait. */
165
166	_LIBCPP_EXPORTED_FROM_ABI
167	void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile* __location)
168	{
169	__libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, true);
170	}
171	_LIBCPP_EXPORTED_FROM_ABI
172	void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile* __location)
173	{
174	__libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, false);
175	}
176	_LIBCPP_EXPORTED_FROM_ABI
177	__cxx_contention_t __libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile* __location)
178	{
179	return __libcpp_contention_monitor_for_wait(&__libcpp_contention_state(__location)->__contention_state, __location);
180	}
181	_LIBCPP_EXPORTED_FROM_ABI
182	void __libcpp_atomic_wait(__cxx_atomic_contention_t const volatile* __location, __cxx_contention_t __old_value)
183	{
184	__libcpp_contention_wait(&__libcpp_contention_state(__location)->__contention_state, __location, __old_value);
185	}
186
187	_LIBCPP_END_NAMESPACE_STD
188
189	#endif //_LIBCPP_HAS_NO_THREADS

lib/libcxx/src/barrier.cpp created+103

...	@@ -0,0 +1,103 @@
1	//===------------------------- barrier.cpp ---------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#include <__config>
10
11	#ifndef _LIBCPP_HAS_NO_THREADS
12
13	#include <barrier>
14	#include <thread>
15
16	_LIBCPP_BEGIN_NAMESPACE_STD
17
18	#if !defined(_LIBCPP_HAS_NO_TREE_BARRIER) && (_LIBCPP_STD_VER > 11)
19
20	class __barrier_algorithm_base {
21	public:
22	struct alignas(64) /* naturally-align the heap state */ __state_t
23	{
24	struct {
25	__atomic_base<__barrier_phase_t> __phase = ATOMIC_VAR_INIT(0);
26	} __tickets[64];
27	};
28
29	ptrdiff_t& __expected;
30	unique_ptr<char[]> __state_allocation;
31	__state_t* __state;
32
33	_LIBCPP_HIDDEN
34	__barrier_algorithm_base(ptrdiff_t& __expected)
35	: __expected(__expected)
36	{
37	size_t const __count = (__expected + 1) >> 1;
38	size_t const __size = sizeof(__state_t) * __count;
39	size_t __allocation_size = __size + alignof(__state_t);
40	__state_allocation = unique_ptr<char[]>(new char[__allocation_size]);
41	void* __allocation = __state_allocation.get();
42	void* const __state_ = align(alignof(__state_t), __size, __allocation, __allocation_size);
43	__state = new (__state_) __barrier_algorithm_base::__state_t[__count];
44	}
45	_LIBCPP_HIDDEN
46	bool __arrive(__barrier_phase_t __old_phase)
47	{
48	__barrier_phase_t const __half_step = __old_phase + 1,
49	__full_step = __old_phase + 2;
50	size_t __current_expected = __expected,
51	__current = hash<thread::id>()(this_thread::get_id()) % ((__expected + 1) >> 1);
52	for(int __round = 0;; ++__round) {
53	if(__current_expected <= 1)
54	return true;
55	size_t const __end_node = ((__current_expected + 1) >> 1),
56	__last_node = __end_node - 1;
57	for(;;++__current) {
58	if(__current == __end_node)
59	__current = 0;
60	__barrier_phase_t expect = __old_phase;
61	if(__current == __last_node && (__current_expected & 1))
62	{
63	if(__state[__current].__tickets[__round].__phase.compare_exchange_strong(expect, __full_step, memory_order_acq_rel))
64	break; // I'm 1 in 1, go to next __round
65	}
66	else if(__state[__current].__tickets[__round].__phase.compare_exchange_strong(expect, __half_step, memory_order_acq_rel))
67	{
68	return false; // I'm 1 in 2, done with arrival
69	}
70	else if(expect == __half_step)
71	{
72	if(__state[__current].__tickets[__round].__phase.compare_exchange_strong(expect, __full_step, memory_order_acq_rel))
73	break; // I'm 2 in 2, go to next __round
74	}
75	}
76	__current_expected = __last_node + 1;
77	__current >>= 1;
78	}
79	}
80	};
81
82	_LIBCPP_EXPORTED_FROM_ABI
83	__barrier_algorithm_base * __construct_barrier_algorithm_base(ptrdiff_t& __expected)
84	{
85	return new __barrier_algorithm_base(__expected);
86	}
87	_LIBCPP_EXPORTED_FROM_ABI
88	bool __arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier,
89	__barrier_phase_t __old_phase)
90	{
91	return __barrier->__arrive(__old_phase);
92	}
93	_LIBCPP_EXPORTED_FROM_ABI
94	void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier)
95	{
96	delete __barrier;
97	}
98
99	#endif //!defined(_LIBCPP_HAS_NO_TREE_BARRIER) && (_LIBCPP_STD_VER >= 11)
100
101	_LIBCPP_END_NAMESPACE_STD
102
103	#endif //_LIBCPP_HAS_NO_THREADS

lib/libcxx/src/charconv.cpp+9-9

...	@@ -32,7 +32,7 @@ static constexpr char cDigitsLut[200] = {	...	@@ -32,7 +32,7 @@ static constexpr char cDigitsLut[200] = {
32		32
33	template <typename T>	33	template <typename T>
34	inline _LIBCPP_INLINE_VISIBILITY char*	34	inline _LIBCPP_INLINE_VISIBILITY char*
35	append1(char* buffer, T i)	35	append1(char* buffer, T i) noexcept
36	{	36	{
37	*buffer = '0' + static_cast<char>(i);	37	*buffer = '0' + static_cast<char>(i);
38	return buffer + 1;	38	return buffer + 1;
...	@@ -40,7 +40,7 @@ append1(char* buffer, T i)	...	@@ -40,7 +40,7 @@ append1(char* buffer, T i)
40		40
41	template <typename T>	41	template <typename T>
42	inline _LIBCPP_INLINE_VISIBILITY char*	42	inline _LIBCPP_INLINE_VISIBILITY char*
43	append2(char* buffer, T i)	43	append2(char* buffer, T i) noexcept
44	{	44	{
45	memcpy(buffer, &cDigitsLut[(i)*2], 2);	45	memcpy(buffer, &cDigitsLut[(i)*2], 2);
46	return buffer + 2;	46	return buffer + 2;
...	@@ -48,21 +48,21 @@ append2(char* buffer, T i)	...	@@ -48,21 +48,21 @@ append2(char* buffer, T i)
48		48
49	template <typename T>	49	template <typename T>
50	inline _LIBCPP_INLINE_VISIBILITY char*	50	inline _LIBCPP_INLINE_VISIBILITY char*
51	append3(char* buffer, T i)	51	append3(char* buffer, T i) noexcept
52	{	52	{
53	return append2(append1(buffer, (i) / 100), (i) % 100);	53	return append2(append1(buffer, (i) / 100), (i) % 100);
54	}	54	}
55		55
56	template <typename T>	56	template <typename T>
57	inline _LIBCPP_INLINE_VISIBILITY char*	57	inline _LIBCPP_INLINE_VISIBILITY char*
58	append4(char* buffer, T i)	58	append4(char* buffer, T i) noexcept
59	{	59	{
60	return append2(append2(buffer, (i) / 100), (i) % 100);	60	return append2(append2(buffer, (i) / 100), (i) % 100);
61	}	61	}
62		62
63	template <typename T>	63	template <typename T>
64	inline _LIBCPP_INLINE_VISIBILITY char*	64	inline _LIBCPP_INLINE_VISIBILITY char*
65	append2_no_zeros(char* buffer, T v)	65	append2_no_zeros(char* buffer, T v) noexcept
66	{	66	{
67	if (v < 10)	67	if (v < 10)
68	return append1(buffer, v);	68	return append1(buffer, v);
...	@@ -72,7 +72,7 @@ append2_no_zeros(char* buffer, T v)	...	@@ -72,7 +72,7 @@ append2_no_zeros(char* buffer, T v)
72		72
73	template <typename T>	73	template <typename T>
74	inline _LIBCPP_INLINE_VISIBILITY char*	74	inline _LIBCPP_INLINE_VISIBILITY char*
75	append4_no_zeros(char* buffer, T v)	75	append4_no_zeros(char* buffer, T v) noexcept
76	{	76	{
77	if (v < 100)	77	if (v < 100)
78	return append2_no_zeros(buffer, v);	78	return append2_no_zeros(buffer, v);
...	@@ -84,7 +84,7 @@ append4_no_zeros(char* buffer, T v)	...	@@ -84,7 +84,7 @@ append4_no_zeros(char* buffer, T v)
84		84
85	template <typename T>	85	template <typename T>
86	inline _LIBCPP_INLINE_VISIBILITY char*	86	inline _LIBCPP_INLINE_VISIBILITY char*
87	append8_no_zeros(char* buffer, T v)	87	append8_no_zeros(char* buffer, T v) noexcept
88	{	88	{
89	if (v < 10000)	89	if (v < 10000)
90	{	90	{
...	@@ -99,7 +99,7 @@ append8_no_zeros(char* buffer, T v)	...	@@ -99,7 +99,7 @@ append8_no_zeros(char* buffer, T v)
99	}	99	}
100		100
101	char*	101	char*
102	__u32toa(uint32_t value, char* buffer)	102	__u32toa(uint32_t value, char* buffer) _NOEXCEPT
103	{	103	{
104	if (value < 100000000)	104	if (value < 100000000)
105	{	105	{
...	@@ -120,7 +120,7 @@ __u32toa(uint32_t value, char* buffer)	...	@@ -120,7 +120,7 @@ __u32toa(uint32_t value, char* buffer)
120	}	120	}
121		121
122	char*	122	char*
123	__u64toa(uint64_t value, char* buffer)	123	__u64toa(uint64_t value, char* buffer) _NOEXCEPT
124	{	124	{
125	if (value < 100000000)	125	if (value < 100000000)
126	{	126	{

lib/libcxx/src/chrono.cpp+31-89

 @@ -9,36 +9,32 @@
 #include "chrono"
 #include "cerrno"        // errno
 #include "system_error"  // __throw_system_error
-#include <time.h>        // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME
+#include <time.h>        // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW}
 #include "include/apple_availability.h"
-#if !defined(__APPLE__)
+#if __has_include(<unistd.h>)
+#include <unistd.h>
+#endif
+#if !defined(__APPLE__) && _POSIX_TIMERS > 0
 #define _LIBCPP_USE_CLOCK_GETTIME
-#endif // __APPLE__
+#endif
 #if defined(_LIBCPP_WIN32API)
-#define WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
-#define VC_EXTRA_LEAN
+#  define VC_EXTRA_LEAN
-#include <windows.h>
+#  include <windows.h>
-#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
+#  if _WIN32_WINNT >= _WIN32_WINNT_WIN8
-#include <winapifamily.h>
+#    include <winapifamily.h>
-#endif
+#  endif
 #else
-#if !defined(CLOCK_REALTIME) || !defined(_LIBCPP_USE_CLOCK_GETTIME)
+#  if !defined(CLOCK_REALTIME)
-#include <sys/time.h>        // for gettimeofday and timeval
+#    include <sys/time.h>        // for gettimeofday and timeval
-#endif // !defined(CLOCK_REALTIME)
+#  endif // !defined(CLOCK_REALTIME)
 #endif // defined(_LIBCPP_WIN32API)
-#if !defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
-#if __APPLE__
-#include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
-#elif !defined(_LIBCPP_WIN32API) && !defined(CLOCK_MONOTONIC)
-#error "Monotonic clock not implemented"
-#endif
-#endif
 #if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
-#pragma comment(lib, "rt")
+#  pragma comment(lib, "rt")
 #endif
 _LIBCPP_BEGIN_NAMESPACE_STD
 @@ -78,7 +74,7 @@ system_clock::now() _NOEXCEPT
                        static_cast<__int64>(ft.dwLowDateTime)};
   return time_point(duration_cast<duration>(d - nt_to_unix_epoch));
 #else
-#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
+#if defined(CLOCK_REALTIME)
   struct timespec tp;
   if (0 != clock_gettime(CLOCK_REALTIME, &tp))
     __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
 @@ -87,7 +83,7 @@ system_clock::now() _NOEXCEPT
     timeval tv;
     gettimeofday(&tv, 0);
     return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
-#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
+#endif // CLOCK_REALTIME
 #endif
 }
 @@ -114,71 +110,24 @@ const bool steady_clock::is_steady;
 #if defined(__APPLE__)
-// Darwin libc versions >= 1133 provide ns precision via CLOCK_UPTIME_RAW
+#if !defined(CLOCK_MONOTONIC_RAW)
-#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW)
+#  error "Building libc++ on Apple platforms requires CLOCK_MONOTONIC_RAW"
+#endif
+// On Apple platforms, only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or
+// mach_absolute_time are able to time functions in the nanosecond range.
+// Furthermore, only CLOCK_MONOTONIC_RAW is truly monotonic, because it
+// also counts cycles when the system is asleep. Thus, it is the only
+// acceptable implementation of steady_clock.
 steady_clock::time_point
 steady_clock::now() _NOEXCEPT
 {
     struct timespec tp;
-    if (0 != clock_gettime(CLOCK_UPTIME_RAW, &tp))
+    if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp))
-        __throw_system_error(errno, "clock_gettime(CLOCK_UPTIME_RAW) failed");
+        __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
     return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
 }
-#else
-//   mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
-//   nanoseconds since the computer booted up.  MachInfo.numer and MachInfo.denom
-//   are run time constants supplied by the OS.  This clock has no relationship
-//   to the Gregorian calendar.  It's main use is as a high resolution timer.
-// MachInfo.numer / MachInfo.denom is often 1 on the latest equipment.  Specialize
-//   for that case as an optimization.
-static
-steady_clock::rep
-steady_simplified()
-{
-    return static_cast<steady_clock::rep>(mach_absolute_time());
-}
-static
-double
-compute_steady_factor()
-{
-    mach_timebase_info_data_t MachInfo;
-    mach_timebase_info(&MachInfo);
-    return static_cast<double>(MachInfo.numer) / MachInfo.denom;
-}
-static
-steady_clock::rep
-steady_full()
-{
-    static const double factor = compute_steady_factor();
-    return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
-}
-typedef steady_clock::rep (*FP)();
-static
-FP
-init_steady_clock()
-{
-    mach_timebase_info_data_t MachInfo;
-    mach_timebase_info(&MachInfo);
-    if (MachInfo.numer == MachInfo.denom)
-        return &steady_simplified;
-    return &steady_full;
-}
-steady_clock::time_point
-steady_clock::now() _NOEXCEPT
-{
-    static FP fp = init_steady_clock();
-    return time_point(duration(fp()));
-}
-#endif // defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW)
 #elif defined(_LIBCPP_WIN32API)
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx says:
 @@ -206,13 +155,6 @@ steady_clock::now() _NOEXCEPT
 #elif defined(CLOCK_MONOTONIC)
-// On Apple platforms only CLOCK_UPTIME_RAW or mach_absolute_time are able to
-// time functions in the nanosecond range. Thus, they are the only acceptable
-// implementations of steady_clock.
-#ifdef __APPLE__
-#error "Never use CLOCK_MONOTONIC for steady_clock::now on Apple platforms"
-#endif
 steady_clock::time_point
 steady_clock::now() _NOEXCEPT
 {
 @@ -223,7 +165,7 @@ steady_clock::now() _NOEXCEPT
 }
 #else
-#error "Monotonic clock not implemented"
+#  error "Monotonic clock not implemented"
 #endif
 #endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK

lib/libcxx/src/filesystem/int128_builtins.cpp created+54

...	@@ -0,0 +1,54 @@
1	/*===-- int128_builtins.cpp - Implement __muloti4 --------------------------===
2	*
3	* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	* See https://llvm.org/LICENSE.txt for license information.
5	* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	*
7	* ===----------------------------------------------------------------------===
8	*
9	* This file implements __muloti4, and is stolen from the compiler_rt library.
10	*
11	* FIXME: we steal and re-compile it into filesystem, which uses __int128_t,
12	* and requires this builtin when sanitized. See llvm.org/PR30643
13	*
14	* ===----------------------------------------------------------------------===
15	*/
16	#include "__config"
17	#include "climits"
18
19	#if !defined(_LIBCPP_HAS_NO_INT128)
20
21	extern "C" __attribute__((no_sanitize("undefined"))) _LIBCPP_FUNC_VIS
22	__int128_t __muloti4(__int128_t a, __int128_t b, int* overflow) {
23	const int N = (int)(sizeof(__int128_t) * CHAR_BIT);
24	const __int128_t MIN = (__int128_t)1 << (N - 1);
25	const __int128_t MAX = ~MIN;
26	*overflow = 0;
27	__int128_t result = a * b;
28	if (a == MIN) {
29	if (b != 0 && b != 1)
30	*overflow = 1;
31	return result;
32	}
33	if (b == MIN) {
34	if (a != 0 && a != 1)
35	*overflow = 1;
36	return result;
37	}
38	__int128_t sa = a >> (N - 1);
39	__int128_t abs_a = (a ^ sa) - sa;
40	__int128_t sb = b >> (N - 1);
41	__int128_t abs_b = (b ^ sb) - sb;
42	if (abs_a < 2 \|\| abs_b < 2)
43	return result;
44	if (sa == sb) {
45	if (abs_a > MAX / abs_b)
46	*overflow = 1;
47	} else {
48	if (abs_a > MIN / -abs_b)
49	*overflow = 1;
50	}
51	return result;
52	}
53
54	#endif

lib/libcxx/src/filesystem/operations.cpp+4-8

 @@ -36,13 +36,9 @@
 #define _LIBCPP_USE_COPYFILE
 #endif
-#if !defined(__APPLE__)
+#if !defined(CLOCK_REALTIME)
-#define _LIBCPP_USE_CLOCK_GETTIME
-#endif
-#if !defined(CLOCK_REALTIME) || !defined(_LIBCPP_USE_CLOCK_GETTIME)
 #include <sys/time.h> // for gettimeofday and timeval
-#endif                // !defined(CLOCK_REALTIME)
+#endif // !defined(CLOCK_REALTIME)
 #if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
 #pragma comment(lib, "rt")
 @@ -490,7 +486,7 @@ const bool _FilesystemClock::is_steady;
 _FilesystemClock::time_point _FilesystemClock::now() noexcept {
   typedef chrono::duration<rep> __secs;
-#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
+#if defined(CLOCK_REALTIME)
   typedef chrono::duration<rep, nano> __nsecs;
   struct timespec tp;
   if (0 != clock_gettime(CLOCK_REALTIME, &tp))
 @@ -502,7 +498,7 @@ _FilesystemClock::time_point _FilesystemClock::now() noexcept {
   timeval tv;
   gettimeofday(&tv, 0);
   return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
-#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
+#endif // CLOCK_REALTIME
 }
 filesystem_error::~filesystem_error() {}

lib/libcxx/src/include/apple_availability.h+8-8

...	@@ -29,20 +29,20 @@	...	@@ -29,20 +29,20 @@
29	#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__	29	#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
30		30
31	#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)	31	#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
32	#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200	32	#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500
33	#define _LIBCPP_USE_CLOCK_GETTIME	33	#define _LIBCPP_USE_ULOCK
34	#endif	34	#endif
35	#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)	35	#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
36	#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000	36	#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000
37	#define _LIBCPP_USE_CLOCK_GETTIME	37	#define _LIBCPP_USE_ULOCK
38	#endif	38	#endif
39	#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)	39	#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
40	#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000	40	#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 130000
41	#define _LIBCPP_USE_CLOCK_GETTIME	41	#define _LIBCPP_USE_ULOCK
42	#endif	42	#endif
43	#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)	43	#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
44	#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000	44	#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 60000
45	#define _LIBCPP_USE_CLOCK_GETTIME	45	#define _LIBCPP_USE_ULOCK
46	#endif	46	#endif
47	#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__	47	#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
48		48

lib/libcxx/src/locale.cpp+2-2

...	@@ -536,7 +536,7 @@ locale::operator=(const locale& other) _NOEXCEPT	...	@@ -536,7 +536,7 @@ locale::operator=(const locale& other) _NOEXCEPT
536		536
537	locale::locale(const char* name)	537	locale::locale(const char* name)
538	: __locale_(name ? new __imp(name)	538	: __locale_(name ? new __imp(name)
539	: (__throw_runtime_error("locale constructed with null"), (__imp*)0))	539	: (__throw_runtime_error("locale constructed with null"), nullptr))
540	{	540	{
541	__locale_->__add_shared();	541	__locale_->__add_shared();
542	}	542	}
...	@@ -549,7 +549,7 @@ locale::locale(const string& name)	...	@@ -549,7 +549,7 @@ locale::locale(const string& name)
549		549
550	locale::locale(const locale& other, const char* name, category c)	550	locale::locale(const locale& other, const char* name, category c)
551	: __locale_(name ? new __imp(*other.__locale_, name, c)	551	: __locale_(name ? new __imp(*other.__locale_, name, c)
552	: (__throw_runtime_error("locale constructed with null"), (__imp*)0))	552	: (__throw_runtime_error("locale constructed with null"), nullptr))
553	{	553	{
554	__locale_->__add_shared();	554	__locale_->__add_shared();
555	}	555	}

lib/libcxx/src/random_shuffle.cpp created+61

...	@@ -0,0 +1,61 @@
1	//===----------------------- random_shuffle.cpp ---------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#include "algorithm"
10	#include "random"
11	#ifndef _LIBCPP_HAS_NO_THREADS
12	# include "mutex"
13	# if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
14	# pragma comment(lib, "pthread")
15	# endif
16	#endif
17
18	_LIBCPP_BEGIN_NAMESPACE_STD
19
20	#ifndef _LIBCPP_HAS_NO_THREADS
21	_LIBCPP_SAFE_STATIC static __libcpp_mutex_t __rs_mut = _LIBCPP_MUTEX_INITIALIZER;
22	#endif
23	unsigned __rs_default::__c_ = 0;
24
25	__rs_default::__rs_default()
26	{
27	#ifndef _LIBCPP_HAS_NO_THREADS
28	__libcpp_mutex_lock(&__rs_mut);
29	#endif
30	__c_ = 1;
31	}
32
33	__rs_default::__rs_default(const __rs_default&)
34	{
35	++__c_;
36	}
37
38	__rs_default::~__rs_default()
39	{
40	#ifndef _LIBCPP_HAS_NO_THREADS
41	if (--__c_ == 0)
42	__libcpp_mutex_unlock(&__rs_mut);
43	#else
44	--__c_;
45	#endif
46	}
47
48	__rs_default::result_type
49	__rs_default::operator()()
50	{
51	static mt19937 __rs_g;
52	return __rs_g();
53	}
54
55	__rs_default
56	__rs_get()
57	{
58	return __rs_default();
59	}
60
61	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/src/string.cpp+7-2

 @@ -20,8 +20,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __basic_string_common<true>;
-template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_string<char>;
+#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
-template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_string<wchar_t>;
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
+#else
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
+#endif
 template
     string

lib/libcxx/src/thread.cpp+3-3

...	@@ -23,9 +23,9 @@	...	@@ -23,9 +23,9 @@
23	# endif	23	# endif
24	#endif // defined(__unix__) \|\| (defined(__APPLE__) && defined(__MACH__))	24	#endif // defined(__unix__) \|\| (defined(__APPLE__) && defined(__MACH__))
25		25
26	#if defined(__unix__) \|\| (defined(__APPLE__) && defined(__MACH__)) \|\| defined(__CloudABI__) \|\| defined(__Fuchsia__) \|\| defined(__wasi__)	26	#if __has_include(<unistd.h>)
27	# include <unistd.h>	27	#include <unistd.h>
28	#endif // defined(__unix__) \|\| (defined(__APPLE__) && defined(__MACH__)) \|\| defined(__CloudABI__) \|\| defined(__Fuchsia__) \|\| defined(__wasi__)	28	#endif
29		29
30	#if defined(__NetBSD__)	30	#if defined(__NetBSD__)
31	#pragma weak pthread_create // Do not create libpthread dependency	31	#pragma weak pthread_create // Do not create libpthread dependency

author	Andrew Kelley <andrew@ziglang.org> 2020-08-04 17:26:02-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-08-04 17:26:02-07:00
log	54b67c20259f697f1e0c4532a5ee7e5d3f01eb1e
tree	d91b41ddd5dd4b9b941691722ce6427b3b82fe59
parent	16513fee6c9c229e40f5abd82220a6f30e8e2180

...	@@ -999,7 +999,7 @@ basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)	...	@@ -999,7 +999,7 @@ basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
999	}	999	}
1000		1000
1001	template <class _CharT, class _Traits>	1001	template <class _CharT, class _Traits>
1002	inline _LIBCPP_INLINE_VISIBILITY	1002	inline
1003	basic_ostream<_CharT, _Traits>&	1003	basic_ostream<_CharT, _Traits>&
1004	endl(basic_ostream<_CharT, _Traits>& __os)	1004	endl(basic_ostream<_CharT, _Traits>& __os)
1005	{	1005	{
...	@@ -1009,7 +1009,7 @@ endl(basic_ostream<_CharT, _Traits>& __os)	...	@@ -1009,7 +1009,7 @@ endl(basic_ostream<_CharT, _Traits>& __os)
1009	}	1009	}
1010		1010
1011	template <class _CharT, class _Traits>	1011	template <class _CharT, class _Traits>
1012	inline _LIBCPP_INLINE_VISIBILITY	1012	inline
1013	basic_ostream<_CharT, _Traits>&	1013	basic_ostream<_CharT, _Traits>&
1014	ends(basic_ostream<_CharT, _Traits>& __os)	1014	ends(basic_ostream<_CharT, _Traits>& __os)
1015	{	1015	{
...	@@ -1018,7 +1018,7 @@ ends(basic_ostream<_CharT, _Traits>& __os)	...	@@ -1018,7 +1018,7 @@ ends(basic_ostream<_CharT, _Traits>& __os)
1018	}	1018	}
1019		1019
1020	template <class _CharT, class _Traits>	1020	template <class _CharT, class _Traits>
1021	inline _LIBCPP_INLINE_VISIBILITY	1021	inline
1022	basic_ostream<_CharT, _Traits>&	1022	basic_ostream<_CharT, _Traits>&
1023	flush(basic_ostream<_CharT, _Traits>& __os)	1023	flush(basic_ostream<_CharT, _Traits>& __os)
1024	{	1024	{

libcxx: update from LLVM 10 to 11rc1