Commit 2289036a40082eb5316e2a46fb2f3a78a8be0c7d | zig

lib/libcxx/include/__bit_reference+18-8

...	@@ -47,6 +47,9 @@ class __bit_reference	...	@@ -47,6 +47,9 @@ class __bit_reference
47	friend class __bit_const_reference<_Cp>;	47	friend class __bit_const_reference<_Cp>;
48	friend class __bit_iterator<_Cp, false>;	48	friend class __bit_iterator<_Cp, false>;
49	public:	49	public:
		50	_LIBCPP_INLINE_VISIBILITY
		51	__bit_reference(const __bit_reference&) = default;
		52
50	_LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT	53	_LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
51	{return static_cast<bool>(*__seg_ & __mask_);}	54	{return static_cast<bool>(*__seg_ & __mask_);}
52	_LIBCPP_INLINE_VISIBILITY bool operator ~() const _NOEXCEPT	55	_LIBCPP_INLINE_VISIBILITY bool operator ~() const _NOEXCEPT
...	@@ -132,6 +135,9 @@ class __bit_const_reference	...	@@ -132,6 +135,9 @@ class __bit_const_reference
132	friend typename _Cp::__self;	135	friend typename _Cp::__self;
133	friend class __bit_iterator<_Cp, true>;	136	friend class __bit_iterator<_Cp, true>;
134	public:	137	public:
		138	_LIBCPP_INLINE_VISIBILITY
		139	__bit_const_reference(const __bit_const_reference&) = default;
		140
135	_LIBCPP_INLINE_VISIBILITY	141	_LIBCPP_INLINE_VISIBILITY
136	__bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT	142	__bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
137	: __seg_(__x.__seg_), __mask_(__x.__mask_) {}	143	: __seg_(__x.__seg_), __mask_(__x.__mask_) {}
...	@@ -147,7 +153,7 @@ private:	...	@@ -147,7 +153,7 @@ private:
147	__bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT	153	__bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
148	: __seg_(__s), __mask_(__m) {}	154	: __seg_(__s), __mask_(__m) {}
149		155
150	__bit_const_reference& operator=(const __bit_const_reference& __x);	156	__bit_const_reference& operator=(const __bit_const_reference&) = delete;
151	};	157	};
152		158
153	// find	159	// find
...	@@ -332,7 +338,7 @@ __fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)	...	@@ -332,7 +338,7 @@ __fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
332	}	338	}
333	// do middle whole words	339	// do middle whole words
334	__storage_type __nw = __n / __bits_per_word;	340	__storage_type __nw = __n / __bits_per_word;
335	_VSTD::memset(_VSTD::__to_raw_pointer(__first.__seg_), 0, __nw * sizeof(__storage_type));	341	_VSTD::memset(_VSTD::__to_address(__first.__seg_), 0, __nw * sizeof(__storage_type));
336	__n -= __nw * __bits_per_word;	342	__n -= __nw * __bits_per_word;
337	// do last partial word	343	// do last partial word
338	if (__n > 0)	344	if (__n > 0)
...	@@ -362,7 +368,7 @@ __fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)	...	@@ -362,7 +368,7 @@ __fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
362	}	368	}
363	// do middle whole words	369	// do middle whole words
364	__storage_type __nw = __n / __bits_per_word;	370	__storage_type __nw = __n / __bits_per_word;
365	_VSTD::memset(_VSTD::__to_raw_pointer(__first.__seg_), -1, __nw * sizeof(__storage_type));	371	_VSTD::memset(_VSTD::__to_address(__first.__seg_), -1, __nw * sizeof(__storage_type));
366	__n -= __nw * __bits_per_word;	372	__n -= __nw * __bits_per_word;
367	// do last partial word	373	// do last partial word
368	if (__n > 0)	374	if (__n > 0)
...	@@ -429,8 +435,8 @@ __copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsCon	...	@@ -429,8 +435,8 @@ __copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsCon
429	// __first.__ctz_ == 0;	435	// __first.__ctz_ == 0;
430	// do middle words	436	// do middle words
431	__storage_type __nw = __n / __bits_per_word;	437	__storage_type __nw = __n / __bits_per_word;
432	_VSTD::memmove(_VSTD::__to_raw_pointer(__result.__seg_),	438	_VSTD::memmove(_VSTD::__to_address(__result.__seg_),
433	_VSTD::__to_raw_pointer(__first.__seg_),	439	_VSTD::__to_address(__first.__seg_),
434	__nw * sizeof(__storage_type));	440	__nw * sizeof(__storage_type));
435	__n -= __nw * __bits_per_word;	441	__n -= __nw * __bits_per_word;
436	__result.__seg_ += __nw;	442	__result.__seg_ += __nw;
...	@@ -570,8 +576,8 @@ __copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_C	...	@@ -570,8 +576,8 @@ __copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_C
570	__storage_type __nw = __n / __bits_per_word;	576	__storage_type __nw = __n / __bits_per_word;
571	__result.__seg_ -= __nw;	577	__result.__seg_ -= __nw;
572	__last.__seg_ -= __nw;	578	__last.__seg_ -= __nw;
573	_VSTD::memmove(_VSTD::__to_raw_pointer(__result.__seg_),	579	_VSTD::memmove(_VSTD::__to_address(__result.__seg_),
574	_VSTD::__to_raw_pointer(__last.__seg_),	580	_VSTD::__to_address(__last.__seg_),
575	__nw * sizeof(__storage_type));	581	__nw * sizeof(__storage_type));
576	__n -= __nw * __bits_per_word;	582	__n -= __nw * __bits_per_word;
577	// do last word	583	// do last word
...	@@ -1108,8 +1114,12 @@ public:	...	@@ -1108,8 +1114,12 @@ public:
1108	#endif	1114	#endif
1109	{}	1115	{}
1110		1116
		1117	// avoid re-declaring a copy constructor for the non-const version.
		1118	using __type_for_copy_to_const =
		1119	_If<_IsConst, __bit_iterator<_Cp, false>, struct __private_nat>;
		1120
1111	_LIBCPP_INLINE_VISIBILITY	1121	_LIBCPP_INLINE_VISIBILITY
1112	__bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT	1122	__bit_iterator(const __type_for_copy_to_const& __it) _NOEXCEPT
1113	: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}	1123	: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
1114		1124
1115	_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT	1125	_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT

lib/libcxx/include/__config+127-20

 @@ -32,7 +32,7 @@
 #  define _GNUC_VER_NEW 0
 #endif
-#define _LIBCPP_VERSION 9000
+#define _LIBCPP_VERSION 10000
 #ifndef _LIBCPP_ABI_VERSION
 #  define _LIBCPP_ABI_VERSION 1
 @@ -183,10 +183,6 @@
 #  define _LIBCPP_COMPILER_IBM
 #endif
-#ifndef _LIBCPP_CLANG_VER
-#define _LIBCPP_CLANG_VER 0
-#endif
 #if defined(_LIBCPP_COMPILER_GCC) && __cplusplus < 201103L
 #error "libc++ does not support using GCC with C++03. Please enable C++11"
 #endif
 @@ -246,6 +242,7 @@
 #ifdef __FreeBSD__
 #  include <sys/endian.h>
+#  include <osreldate.h>
 #  if _BYTE_ORDER == _LITTLE_ENDIAN
 #    define _LIBCPP_LITTLE_ENDIAN
 #  else  // _BYTE_ORDER == _LITTLE_ENDIAN
 @@ -263,7 +260,6 @@
 #  else  // _BYTE_ORDER == _LITTLE_ENDIAN
 #    define _LIBCPP_BIG_ENDIAN
 #  endif  // _BYTE_ORDER == _LITTLE_ENDIAN
-#  define _LIBCPP_HAS_QUICK_EXIT
 #endif  // __NetBSD__
 #if defined(_WIN32)
 @@ -343,9 +339,26 @@
 #if __ISO_C_VISIBLE >= 2011 || __cplusplus >= 201103L
 #  if defined(__FreeBSD__)
+#    define _LIBCPP_HAS_ALIGNED_ALLOC
 #    define _LIBCPP_HAS_QUICK_EXIT
 #    define _LIBCPP_HAS_C11_FEATURES
-#  elif defined(__Fuchsia__) || defined(__wasi__)
+#    if __FreeBSD_version >= 1300064 || \
+       (__FreeBSD_version >= 1201504 && __FreeBSD_version < 1300000)
+#      define _LIBCPP_HAS_TIMESPEC_GET
+#    endif
+#  elif defined(__BIONIC__)
+#    define _LIBCPP_HAS_C11_FEATURES
+#    if __ANDROID_API__ >= 21
+#      define _LIBCPP_HAS_QUICK_EXIT
+#    endif
+#    if __ANDROID_API__ >= 28
+#      define _LIBCPP_HAS_ALIGNED_ALLOC
+#    endif
+#    if __ANDROID_API__ >= 29
+#      define _LIBCPP_HAS_TIMESPEC_GET
+#    endif
+#  elif defined(__Fuchsia__) || defined(__wasi__) || defined(__NetBSD__)
+#    define _LIBCPP_HAS_ALIGNED_ALLOC
 #    define _LIBCPP_HAS_QUICK_EXIT
 #    define _LIBCPP_HAS_TIMESPEC_GET
 #    define _LIBCPP_HAS_C11_FEATURES
 @@ -355,10 +368,12 @@
 #        define _LIBCPP_HAS_QUICK_EXIT
 #      endif
 #      if _LIBCPP_GLIBC_PREREQ(2, 17)
+#        define _LIBCPP_HAS_ALIGNED_ALLOC
 #        define _LIBCPP_HAS_C11_FEATURES
 #        define _LIBCPP_HAS_TIMESPEC_GET
 #      endif
 #    else // defined(_LIBCPP_HAS_MUSL_LIBC)
+#      define _LIBCPP_HAS_ALIGNED_ALLOC
 #      define _LIBCPP_HAS_QUICK_EXIT
 #      define _LIBCPP_HAS_TIMESPEC_GET
 #      define _LIBCPP_HAS_C11_FEATURES
 @@ -483,11 +498,14 @@ typedef __char32_t char32_t;
 #define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
-// No apple compilers support ""d and ""y at this time.
+// Literal operators ""d and ""y are supported starting with LLVM Clang 8 and AppleClang 10.0.1
-#if _LIBCPP_CLANG_VER < 800 || defined(__apple_build_version__)
+#if (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 800) || \
-#define	_LIBCPP_HAS_NO_CXX20_CHRONO_LITERALS
+    (defined(__apple_build_version__) && __apple_build_version__ < 10010000)
+#define _LIBCPP_HAS_NO_CXX20_CHRONO_LITERALS
 #endif
+#define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
 #elif defined(_LIBCPP_COMPILER_GCC)
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
 @@ -523,6 +541,8 @@ typedef __char32_t char32_t;
 #define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
+#define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
 #elif defined(_LIBCPP_COMPILER_MSVC)
 #define _LIBCPP_TOSTRING2(x) #x
 @@ -548,6 +568,8 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_NO_VECTOR_EXTENSION
+#define _LIBCPP_DISABLE_EXTENSION_WARNING
 #elif defined(_LIBCPP_COMPILER_IBM)
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
 @@ -568,6 +590,8 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_NO_VECTOR_EXTENSION
+#define _LIBCPP_DISABLE_EXTENSION_WARNING
 #endif // _LIBCPP_COMPILER_[CLANG|GCC|MSVC|IBM]
 #if defined(_LIBCPP_OBJECT_FORMAT_COFF)
 @@ -860,6 +884,10 @@ typedef unsigned int   char32_t;
 #  endif
 #endif
+#ifndef _LIBCPP_DEBUG_LEVEL
+# define _LIBCPP_DEBUG_LEVEL 0
+#endif
 #ifdef _LIBCPP_DISABLE_EXTERN_TEMPLATE
 #define _LIBCPP_EXTERN_TEMPLATE(...)
 #define _LIBCPP_EXTERN_TEMPLATE2(...)
 @@ -958,6 +986,20 @@ typedef unsigned int   char32_t;
 #  define _LIBCPP_DEPRECATED_IN_CXX17
 #endif
+// Macros to enter and leave a state where deprecation warnings are suppressed.
+#if !defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH) && \
+    (defined(_LIBCPP_COMPILER_CLANG) || defined(_LIBCPP_COMPILER_GCC))
+#  define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
+    _Pragma("GCC diagnostic push") \
+    _Pragma("GCC diagnostic ignored \"-Wdeprecated\"")
+#  define _LIBCPP_SUPPRESS_DEPRECATED_POP \
+    _Pragma("GCC diagnostic pop")
+#endif
+#if !defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH)
+#  define _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+#  define _LIBCPP_SUPPRESS_DEPRECATED_POP
+#endif
 #if _LIBCPP_STD_VER <= 11
 #  define _LIBCPP_EXPLICIT_AFTER_CXX11
 #else
 @@ -982,6 +1024,14 @@ typedef unsigned int   char32_t;
 #  define _LIBCPP_CONSTEXPR_AFTER_CXX17
 #endif
+#if _LIBCPP_STD_VER > 17 && \
+    !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR) && \
+    !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
+#  define _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED constexpr
+#else
+#  define _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
+#endif
 // The _LIBCPP_NODISCARD_ATTRIBUTE should only be used to define other
 // NODISCARD macros to the correct attribute.
 #if __has_cpp_attribute(nodiscard) || defined(_LIBCPP_COMPILER_MSVC)
 @@ -1065,7 +1115,6 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
     !defined(_LIBCPP_HAS_THREAD_API_WIN32) && \
     !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
 #  if defined(__FreeBSD__) || \
-      defined(__Fuchsia__) || \
       defined(__wasi__) || \
       defined(__NetBSD__) || \
       defined(__linux__) || \
 @@ -1075,6 +1124,8 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
       defined(__sun__) || \
       (defined(__MINGW32__) && __has_include(<pthread.h>))
 #    define _LIBCPP_HAS_THREAD_API_PTHREAD
+#  elif defined(__Fuchsia__)
+#    define _LIBCPP_HAS_THREAD_API_C11
 #  elif defined(_LIBCPP_WIN32API)
 #    define _LIBCPP_HAS_THREAD_API_WIN32
 #  else
 @@ -1082,6 +1133,16 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #  endif // _LIBCPP_HAS_THREAD_API
 #endif // _LIBCPP_HAS_NO_THREADS
+#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
+#if defined(__ANDROID__) && __ANDROID_API__ >= 30
+#define _LIBCPP_HAS_COND_CLOCKWAIT
+#elif defined(_LIBCPP_GLIBC_PREREQ)
+#if _LIBCPP_GLIBC_PREREQ(2, 30)
+#define _LIBCPP_HAS_COND_CLOCKWAIT
+#endif
+#endif
+#endif
 #if defined(_LIBCPP_HAS_NO_THREADS) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 #error _LIBCPP_HAS_THREAD_API_PTHREAD may only be defined when \
        _LIBCPP_HAS_NO_THREADS is not defined.
 @@ -1097,20 +1158,40 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
        _LIBCPP_HAS_NO_THREADS is defined.
 #endif
-// The Apple, glibc, and Bionic implementation of pthreads implements
+#if defined(__STDCPP_THREADS__) && defined(_LIBCPP_HAS_NO_THREADS)
+#error _LIBCPP_HAS_NO_THREADS cannot be set when __STDCPP_THREADS__ is set.
+#endif
+#if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(__STDCPP_THREADS__)
+#define __STDCPP_THREADS__ 1
+#endif
+// The glibc and Bionic implementation of pthreads implements
 // pthread_mutex_destroy as nop for regular mutexes. Additionally, Win32
 // mutexes have no destroy mechanism.
-// TODO(EricWF): Enable this optimization on Apple and Bionic platforms after
+//
-// speaking to their respective stakeholders.
+// This optimization can't be performed on Apple platforms, where
+// pthread_mutex_destroy can allow the kernel to release resources.
+// See https://llvm.org/D64298 for details.
+//
+// TODO(EricWF): Enable this optimization on Bionic after speaking to their
+//               respective stakeholders.
 #if (defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && defined(__GLIBC__)) \
+  || (defined(_LIBCPP_HAS_THREAD_API_C11) && defined(__Fuchsia__)) \
   || defined(_LIBCPP_HAS_THREAD_API_WIN32)
 # define _LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION
 #endif
 // Destroying a condvar is a nop on Windows.
+//
+// This optimization can't be performed on Apple platforms, where
+// pthread_cond_destroy can allow the kernel to release resources.
+// See https://llvm.org/D64298 for details.
+//
 // TODO(EricWF): This is potentially true for some pthread implementations
 // as well.
-#if defined(_LIBCPP_HAS_THREAD_API_WIN32)
+#if (defined(_LIBCPP_HAS_THREAD_API_C11) && defined(__Fuchsia__)) || \
+     defined(_LIBCPP_HAS_THREAD_API_WIN32)
 # define _LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION
 #endif
 @@ -1129,6 +1210,14 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #define _LIBCPP_HAS_NO_STDOUT
 #endif
+// Some systems do not provide gets() in their C library, for security reasons.
+#ifndef _LIBCPP_C_HAS_NO_GETS
+#  if defined(_LIBCPP_MSVCRT) || \
+      (defined(__FreeBSD_version) && __FreeBSD_version >= 1300043)
+#    define _LIBCPP_C_HAS_NO_GETS
+#  endif
+#endif
 #if defined(__BIONIC__) || defined(__CloudABI__) ||                            \
     defined(__Fuchsia__) || defined(__wasi__) || defined(_LIBCPP_HAS_MUSL_LIBC)
 #define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 @@ -1175,6 +1264,14 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #  endif
 #endif
+#ifndef _LIBCPP_THREAD_SAFETY_ANNOTATION
+#  ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
+#    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
+#  else
+#    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
+#  endif
+#endif  // _LIBCPP_THREAD_SAFETY_ANNOTATION
 #if __has_attribute(require_constant_initialization)
 #  define _LIBCPP_SAFE_STATIC __attribute__((__require_constant_initialization__))
 #else
 @@ -1210,7 +1307,7 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #  define _LIBCPP_FALLTHROUGH() [[fallthrough]]
 #elif __has_cpp_attribute(clang::fallthrough)
 #  define _LIBCPP_FALLTHROUGH() [[clang::fallthrough]]
-#elif __has_attribute(fallthough) || _GNUC_VER >= 700
+#elif __has_attribute(fallthrough) || _GNUC_VER >= 700
 #  define _LIBCPP_FALLTHROUGH() __attribute__((__fallthrough__))
 #else
 #  define _LIBCPP_FALLTHROUGH() ((void)0)
 @@ -1224,7 +1321,7 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #ifndef _LIBCPP_NODEBUG_TYPE
 #if __has_attribute(__nodebug__) && \
-    (defined(_LIBCPP_COMPILER_CLANG) && _LIBCPP_CLANG_VER >= 900)
+    (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 900)
 #define _LIBCPP_NODEBUG_TYPE __attribute__((nodebug))
 #else
 #define _LIBCPP_NODEBUG_TYPE
 @@ -1257,10 +1354,9 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #define _LIBCPP_HAS_NO_COROUTINES
 #endif
-// FIXME: Correct this macro when either (A) a feature test macro for the
+#if !defined(__cpp_impl_three_way_comparison) || __cpp_impl_three_way_comparison < 201907L
-// spaceship operator is provided, or (B) a compiler provides a complete
-// implementation.
 #define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
+#endif
 // Decide whether to use availability macros.
 #if !defined(_LIBCPP_BUILDING_LIBRARY) &&                                      \
 @@ -1411,6 +1507,17 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 #define _LIBCPP_UNUSED_VAR(x) ((void)(x))
+// Configures the fopen close-on-exec mode character, if any. This string will
+// be appended to any mode string used by fstream for fopen/fdopen.
+//
+// Not all platforms support this, but it helps avoid fd-leaks on platforms that
+// do.
+#if defined(__BIONIC__)
+#  define _LIBCPP_FOPEN_CLOEXEC_MODE "e"
+#else
+#  define _LIBCPP_FOPEN_CLOEXEC_MODE
+#endif
 #endif // __cplusplus
 #endif // _LIBCPP_CONFIG

lib/libcxx/include/__config_site.in+1

...	@@ -29,6 +29,7 @@	...	@@ -29,6 +29,7 @@
29	#cmakedefine _LIBCPP_NO_VCRUNTIME	29	#cmakedefine _LIBCPP_NO_VCRUNTIME
30	#cmakedefine01 _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT	30	#cmakedefine01 _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT
31	#cmakedefine _LIBCPP_ABI_NAMESPACE @_LIBCPP_ABI_NAMESPACE@	31	#cmakedefine _LIBCPP_ABI_NAMESPACE @_LIBCPP_ABI_NAMESPACE@
		32	#cmakedefine _LIBCPP_HAS_PARALLEL_ALGORITHMS
32		33
33	@_LIBCPP_ABI_DEFINES@	34	@_LIBCPP_ABI_DEFINES@
34		35

lib/libcxx/include/__debug-1

...	@@ -276,4 +276,3 @@ _LIBCPP_FUNC_VIS const __libcpp_db* __get_const_db();	...	@@ -276,4 +276,3 @@ _LIBCPP_FUNC_VIS const __libcpp_db* __get_const_db();
276	_LIBCPP_END_NAMESPACE_STD	276	_LIBCPP_END_NAMESPACE_STD
277		277
278	#endif // _LIBCPP_DEBUG_H	278	#endif // _LIBCPP_DEBUG_H
279

lib/libcxx/include/__functional_03+4-4

lib/libcxx/include/__functional_base+1-1

...	@@ -558,7 +558,7 @@ struct __is_transparent<_Tp, _Up,	...	@@ -558,7 +558,7 @@ struct __is_transparent<_Tp, _Up,
558		558
559	// allocator_arg_t	559	// allocator_arg_t
560		560
561	struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { };	561	struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { explicit allocator_arg_t() = default; };
562		562
563	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_LIBRARY)	563	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_LIBRARY)
564	extern _LIBCPP_EXPORTED_FROM_ABI const allocator_arg_t allocator_arg;	564	extern _LIBCPP_EXPORTED_FROM_ABI const allocator_arg_t allocator_arg;

lib/libcxx/include/__hash_table+14-12

...	@@ -776,7 +776,7 @@ public:	...	@@ -776,7 +776,7 @@ public:
776	_LIBCPP_INLINE_VISIBILITY	776	_LIBCPP_INLINE_VISIBILITY
777	__bucket_list_deallocator()	777	__bucket_list_deallocator()
778	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)	778	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
779	: __data_(0) {}	779	: __data_(0, __default_init_tag()) {}
780		780
781	_LIBCPP_INLINE_VISIBILITY	781	_LIBCPP_INLINE_VISIBILITY
782	__bucket_list_deallocator(const allocator_type& __a, size_type __size)	782	__bucket_list_deallocator(const allocator_type& __a, size_type __size)
...	@@ -825,11 +825,13 @@ private:	...	@@ -825,11 +825,13 @@ private:
825		825
826	allocator_type& __na_;	826	allocator_type& __na_;
827		827
828	__hash_node_destructor& operator=(const __hash_node_destructor&);
829
830	public:	828	public:
831	bool __value_constructed;	829	bool __value_constructed;
832		830
		831	__hash_node_destructor(__hash_node_destructor const&) = default;
		832	__hash_node_destructor& operator=(const __hash_node_destructor&) = delete;
		833
		834
833	_LIBCPP_INLINE_VISIBILITY	835	_LIBCPP_INLINE_VISIBILITY
834	explicit __hash_node_destructor(allocator_type& __na,	836	explicit __hash_node_destructor(allocator_type& __na,
835	bool __constructed = false) _NOEXCEPT	837	bool __constructed = false) _NOEXCEPT
...	@@ -1416,8 +1418,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()	...	@@ -1416,8 +1418,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
1416	is_nothrow_default_constructible<__node_allocator>::value &&	1418	is_nothrow_default_constructible<__node_allocator>::value &&
1417	is_nothrow_default_constructible<hasher>::value &&	1419	is_nothrow_default_constructible<hasher>::value &&
1418	is_nothrow_default_constructible<key_equal>::value)	1420	is_nothrow_default_constructible<key_equal>::value)
1419	: __p2_(0),	1421	: __p2_(0, __default_init_tag()),
1420	__p3_(1.0f)	1422	__p3_(1.0f, __default_init_tag())
1421	{	1423	{
1422	}	1424	}
1423		1425
...	@@ -1437,7 +1439,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,	...	@@ -1437,7 +1439,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
1437	const key_equal& __eql,	1439	const key_equal& __eql,
1438	const allocator_type& __a)	1440	const allocator_type& __a)
1439	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),	1441	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
1440	__p1_(__second_tag(), __node_allocator(__a)),	1442	__p1_(__default_init_tag(), __node_allocator(__a)),
1441	__p2_(0, __hf),	1443	__p2_(0, __hf),
1442	__p3_(1.0f, __eql)	1444	__p3_(1.0f, __eql)
1443	{	1445	{
...	@@ -1446,9 +1448,9 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,	...	@@ -1446,9 +1448,9 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
1446	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1448	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1447	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a)	1449	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a)
1448	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),	1450	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
1449	__p1_(__second_tag(), __node_allocator(__a)),	1451	__p1_(__default_init_tag(), __node_allocator(__a)),
1450	__p2_(0),	1452	__p2_(0, __default_init_tag()),
1451	__p3_(1.0f)	1453	__p3_(1.0f, __default_init_tag())
1452	{	1454	{
1453	}	1455	}
1454		1456
...	@@ -1458,7 +1460,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u)	...	@@ -1458,7 +1460,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u)
1458	__bucket_list_deleter(allocator_traits<__pointer_allocator>::	1460	__bucket_list_deleter(allocator_traits<__pointer_allocator>::
1459	select_on_container_copy_construction(	1461	select_on_container_copy_construction(
1460	__u.__bucket_list_.get_deleter().__alloc()), 0)),	1462	__u.__bucket_list_.get_deleter().__alloc()), 0)),
1461	__p1_(__second_tag(), allocator_traits<__node_allocator>::	1463	__p1_(__default_init_tag(), allocator_traits<__node_allocator>::
1462	select_on_container_copy_construction(__u.__node_alloc())),	1464	select_on_container_copy_construction(__u.__node_alloc())),
1463	__p2_(0, __u.hash_function()),	1465	__p2_(0, __u.hash_function()),
1464	__p3_(__u.__p3_)	1466	__p3_(__u.__p3_)
...	@@ -1469,7 +1471,7 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>	...	@@ -1469,7 +1471,7 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
1469	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,	1471	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,
1470	const allocator_type& __a)	1472	const allocator_type& __a)
1471	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),	1473	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
1472	__p1_(__second_tag(), __node_allocator(__a)),	1474	__p1_(__default_init_tag(), __node_allocator(__a)),
1473	__p2_(0, __u.hash_function()),	1475	__p2_(0, __u.hash_function()),
1474	__p3_(__u.__p3_)	1476	__p3_(__u.__p3_)
1475	{	1477	{
...	@@ -1503,7 +1505,7 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>	...	@@ -1503,7 +1505,7 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
1503	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,	1505	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
1504	const allocator_type& __a)	1506	const allocator_type& __a)
1505	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),	1507	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
1506	__p1_(__second_tag(), __node_allocator(__a)),	1508	__p1_(__default_init_tag(), __node_allocator(__a)),
1507	__p2_(0, _VSTD::move(__u.hash_function())),	1509	__p2_(0, _VSTD::move(__u.hash_function())),
1508	__p3_(_VSTD::move(__u.__p3_))	1510	__p3_(_VSTD::move(__u.__p3_))
1509	{	1511	{

lib/libcxx/include/__libcpp_version+1-1

...	@@ -1 +1 @@	...	@@ -1 +1 @@
1	9000	1	10000

lib/libcxx/include/__locale+1-1

...	@@ -409,7 +409,7 @@ public:	...	@@ -409,7 +409,7 @@ public:
409	static const mask xdigit = _ISxdigit;	409	static const mask xdigit = _ISxdigit;
410	static const mask blank = _ISblank;	410	static const mask blank = _ISblank;
411	#if defined(__mips__)	411	#if defined(__mips__)
412	static const mask __regex_word = static_cast<char_class_type>(_ISbit(15));	412	static const mask __regex_word = static_cast<mask>(_ISbit(15));
413	#else	413	#else
414	static const mask __regex_word = 0x80;	414	static const mask __regex_word = 0x80;
415	#endif	415	#endif

lib/libcxx/include/__mutex_base+134-31

...	@@ -15,6 +15,7 @@	...	@@ -15,6 +15,7 @@
15	#include <system_error>	15	#include <system_error>
16	#include <__threading_support>	16	#include <__threading_support>
17		17
		18	#include <time.h>
18		19
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	20	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	#pragma GCC system_header	21	#pragma GCC system_header
...	@@ -28,15 +29,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -28,15 +29,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
28		29
29	#ifndef _LIBCPP_HAS_NO_THREADS	30	#ifndef _LIBCPP_HAS_NO_THREADS
30		31
31	#ifndef _LIBCPP_THREAD_SAFETY_ANNOTATION
32	# ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
33	# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
34	# else
35	# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
36	# endif
37	#endif // _LIBCPP_THREAD_SAFETY_ANNOTATION
38
39
40	class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex	32	class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex
41	{	33	{
42	__libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;	34	__libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
...	@@ -65,9 +57,9 @@ public:	...	@@ -65,9 +57,9 @@ public:
65	static_assert(is_nothrow_default_constructible<mutex>::value,	57	static_assert(is_nothrow_default_constructible<mutex>::value,
66	"the default constructor for std::mutex must be nothrow");	58	"the default constructor for std::mutex must be nothrow");
67		59
68	struct _LIBCPP_TYPE_VIS defer_lock_t {};	60	struct _LIBCPP_TYPE_VIS defer_lock_t { explicit defer_lock_t() = default; };
69	struct _LIBCPP_TYPE_VIS try_to_lock_t {};	61	struct _LIBCPP_TYPE_VIS try_to_lock_t { explicit try_to_lock_t() = default; };
70	struct _LIBCPP_TYPE_VIS adopt_lock_t {};	62	struct _LIBCPP_TYPE_VIS adopt_lock_t { explicit adopt_lock_t() = default; };
71		63
72	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_LIBRARY)	64	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_LIBRARY)
73		65
...	@@ -94,10 +86,11 @@ private:	...	@@ -94,10 +86,11 @@ private:
94	mutex_type& __m_;	86	mutex_type& __m_;
95	public:	87	public:
96		88
97	_LIBCPP_INLINE_VISIBILITY	89	_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
98	explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))	90	explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
99	: __m_(__m) {__m_.lock();}	91	: __m_(__m) {__m_.lock();}
100	_LIBCPP_INLINE_VISIBILITY	92
		93	_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
101	lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))	94	lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
102	: __m_(__m) {}	95	: __m_(__m) {}
103	_LIBCPP_INLINE_VISIBILITY	96	_LIBCPP_INLINE_VISIBILITY
...	@@ -336,23 +329,75 @@ public:	...	@@ -336,23 +329,75 @@ public:
336	private:	329	private:
337	void __do_timed_wait(unique_lock<mutex>& __lk,	330	void __do_timed_wait(unique_lock<mutex>& __lk,
338	chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;	331	chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
		332	#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
		333	void __do_timed_wait(unique_lock<mutex>& __lk,
		334	chrono::time_point<chrono::steady_clock, chrono::nanoseconds>) _NOEXCEPT;
		335	#endif
		336	template <class _Clock>
		337	void __do_timed_wait(unique_lock<mutex>& __lk,
		338	chrono::time_point<_Clock, chrono::nanoseconds>) _NOEXCEPT;
339	};	339	};
340	#endif // !_LIBCPP_HAS_NO_THREADS	340	#endif // !_LIBCPP_HAS_NO_THREADS
341		341
342	template <class _To, class _Rep, class _Period>	342	template <class _Rep, class _Period>
343	inline _LIBCPP_INLINE_VISIBILITY	343	inline _LIBCPP_INLINE_VISIBILITY
344	typename enable_if	344	typename enable_if
345	<	345	<
346	chrono::__is_duration<_To>::value,	346	is_floating_point<_Rep>::value,
347	_To	347	chrono::nanoseconds
348	>::type	348	>::type
349	__ceil(chrono::duration<_Rep, _Period> __d)	349	__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d)
350	{	350	{
351	using namespace chrono;	351	using namespace chrono;
352	_To __r = duration_cast<_To>(__d);	352	using __ratio = ratio_divide<_Period, nano>;
353	if (__r < __d)	353	using __ns_rep = nanoseconds::rep;
354	++__r;	354	_Rep __result_float = __d.count() * __ratio::num / __ratio::den;
355	return __r;	355
		356	_Rep __result_max = numeric_limits<__ns_rep>::max();
		357	if (__result_float >= __result_max) {
		358	return nanoseconds::max();
		359	}
		360
		361	_Rep __result_min = numeric_limits<__ns_rep>::min();
		362	if (__result_float <= __result_min) {
		363	return nanoseconds::min();
		364	}
		365
		366	return nanoseconds(static_cast<__ns_rep>(__result_float));
		367	}
		368
		369	template <class _Rep, class _Period>
		370	inline _LIBCPP_INLINE_VISIBILITY
		371	typename enable_if
		372	<
		373	!is_floating_point<_Rep>::value,
		374	chrono::nanoseconds
		375	>::type
		376	__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d)
		377	{
		378	using namespace chrono;
		379	if (__d.count() == 0) {
		380	return nanoseconds(0);
		381	}
		382
		383	using __ratio = ratio_divide<_Period, nano>;
		384	using __ns_rep = nanoseconds::rep;
		385	__ns_rep __result_max = std::numeric_limits<__ns_rep>::max();
		386	if (__d.count() > 0 && __d.count() > __result_max / __ratio::num) {
		387	return nanoseconds::max();
		388	}
		389
		390	__ns_rep __result_min = std::numeric_limits<__ns_rep>::min();
		391	if (__d.count() < 0 && __d.count() < __result_min / __ratio::num) {
		392	return nanoseconds::min();
		393	}
		394
		395	__ns_rep __result = __d.count() * __ratio::num / __ratio::den;
		396	if (__result == 0) {
		397	return nanoseconds(1);
		398	}
		399
		400	return nanoseconds(__result);
356	}	401	}
357		402
358	#ifndef _LIBCPP_HAS_NO_THREADS	403	#ifndef _LIBCPP_HAS_NO_THREADS
...	@@ -370,7 +415,15 @@ condition_variable::wait_until(unique_lock<mutex>& __lk,	...	@@ -370,7 +415,15 @@ condition_variable::wait_until(unique_lock<mutex>& __lk,
370	const chrono::time_point<_Clock, _Duration>& __t)	415	const chrono::time_point<_Clock, _Duration>& __t)
371	{	416	{
372	using namespace chrono;	417	using namespace chrono;
373	wait_for(__lk, __t - _Clock::now());	418	using __clock_tp_ns = time_point<_Clock, nanoseconds>;
		419
		420	typename _Clock::time_point __now = _Clock::now();
		421	if (__t <= __now)
		422	return cv_status::timeout;
		423
		424	__clock_tp_ns __t_ns = __clock_tp_ns(__safe_nanosecond_cast(__t.time_since_epoch()));
		425
		426	__do_timed_wait(__lk, __t_ns);
374	return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;	427	return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
375	}	428	}
376		429
...	@@ -396,15 +449,25 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,	...	@@ -396,15 +449,25 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
396	using namespace chrono;	449	using namespace chrono;
397	if (__d <= __d.zero())	450	if (__d <= __d.zero())
398	return cv_status::timeout;	451	return cv_status::timeout;
399	typedef time_point<system_clock, duration<long double, nano> > __sys_tpf;	452	using __ns_rep = nanoseconds::rep;
400	typedef time_point<system_clock, nanoseconds> __sys_tpi;
401	__sys_tpf _Max = __sys_tpi::max();
402	steady_clock::time_point __c_now = steady_clock::now();	453	steady_clock::time_point __c_now = steady_clock::now();
403	system_clock::time_point __s_now = system_clock::now();	454
404	if (_Max - __d > __s_now)	455	#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
405	__do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));	456	using __clock_tp_ns = time_point<steady_clock, nanoseconds>;
406	else	457	__ns_rep __now_count_ns = __safe_nanosecond_cast(__c_now.time_since_epoch()).count();
407	__do_timed_wait(__lk, __sys_tpi::max());	458	#else
		459	using __clock_tp_ns = time_point<system_clock, nanoseconds>;
		460	__ns_rep __now_count_ns = __safe_nanosecond_cast(system_clock::now().time_since_epoch()).count();
		461	#endif
		462
		463	__ns_rep __d_ns_count = __safe_nanosecond_cast(__d).count();
		464
		465	if (__now_count_ns > numeric_limits<__ns_rep>::max() - __d_ns_count) {
		466	__do_timed_wait(__lk, __clock_tp_ns::max());
		467	} else {
		468	__do_timed_wait(__lk, __clock_tp_ns(nanoseconds(__now_count_ns + __d_ns_count)));
		469	}
		470
408	return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :	471	return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
409	cv_status::timeout;	472	cv_status::timeout;
410	}	473	}
...	@@ -420,6 +483,46 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,	...	@@ -420,6 +483,46 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
420	_VSTD::move(__pred));	483	_VSTD::move(__pred));
421	}	484	}
422		485
		486	#if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
		487	inline
		488	void
		489	condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
		490	chrono::time_point<chrono::steady_clock, chrono::nanoseconds> __tp) _NOEXCEPT
		491	{
		492	using namespace chrono;
		493	if (!__lk.owns_lock())
		494	__throw_system_error(EPERM,
		495	"condition_variable::timed wait: mutex not locked");
		496	nanoseconds __d = __tp.time_since_epoch();
		497	timespec __ts;
		498	seconds __s = duration_cast<seconds>(__d);
		499	using __ts_sec = decltype(__ts.tv_sec);
		500	const __ts_sec __ts_sec_max = numeric_limits<__ts_sec>::max();
		501	if (__s.count() < __ts_sec_max)
		502	{
		503	__ts.tv_sec = static_cast<__ts_sec>(__s.count());
		504	__ts.tv_nsec = (__d - __s).count();
		505	}
		506	else
		507	{
		508	__ts.tv_sec = __ts_sec_max;
		509	__ts.tv_nsec = giga::num - 1;
		510	}
		511	int __ec = pthread_cond_clockwait(&__cv_, __lk.mutex()->native_handle(), CLOCK_MONOTONIC, &__ts);
		512	if (__ec != 0 && __ec != ETIMEDOUT)
		513	__throw_system_error(__ec, "condition_variable timed_wait failed");
		514	}
		515	#endif // _LIBCPP_HAS_COND_CLOCKWAIT
		516
		517	template <class _Clock>
		518	inline
		519	void
		520	condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
		521	chrono::time_point<_Clock, chrono::nanoseconds> __tp) _NOEXCEPT
		522	{
		523	wait_for(__lk, __tp - _Clock::now());
		524	}
		525
423	#endif // !_LIBCPP_HAS_NO_THREADS	526	#endif // !_LIBCPP_HAS_NO_THREADS
424		527
425	_LIBCPP_END_NAMESPACE_STD	528	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__split_buffer+43-36

 @@ -116,15 +116,15 @@ public:
     template <class _InputIter>
         typename enable_if
         <
-            __is_input_iterator<_InputIter>::value &&
+            __is_cpp17_input_iterator<_InputIter>::value &&
-           !__is_forward_iterator<_InputIter>::value,
+           !__is_cpp17_forward_iterator<_InputIter>::value,
             void
         >::type
         __construct_at_end(_InputIter __first, _InputIter __last);
     template <class _ForwardIterator>
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value,
+            __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 @@ -161,6 +161,19 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT
         {}
+    struct _ConstructTransaction {
+      explicit _ConstructTransaction(pointer* __p, size_type __n) _NOEXCEPT
+      : __pos_(*__p), __end_(*__p + __n), __dest_(__p) {
+      }
+      ~_ConstructTransaction() {
+        *__dest_ = __pos_;
+      }
+      pointer __pos_;
+     const pointer __end_;
+    private:
+     pointer *__dest_;
+    };
 };
 template <class _Tp, class _Allocator>
 @@ -197,13 +210,10 @@ template <class _Tp, class _Allocator>
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
 {
-    __alloc_rr& __a = this->__alloc();
+    _ConstructTransaction __tx(&this->__end_, __n);
-    do
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-    {
+        __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_));
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
+    }
-        ++this->__end_;
-        --__n;
-    } while (__n > 0);
 }
 //  Copy constructs __n objects starting at __end_ from __x
 @@ -216,21 +226,19 @@ template <class _Tp, class _Allocator>
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
-    __alloc_rr& __a = this->__alloc();
+    _ConstructTransaction __tx(&this->__end_, __n);
-    do
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-    {
+        __alloc_traits::construct(this->__alloc(),
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
+            _VSTD::__to_address(__tx.__pos_), __x);
-        ++this->__end_;
+    }
-        --__n;
-    } while (__n > 0);
 }
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 typename enable_if
 <
-     __is_input_iterator<_InputIter>::value &&
+     __is_cpp17_input_iterator<_InputIter>::value &&
-    !__is_forward_iterator<_InputIter>::value,
+    !__is_cpp17_forward_iterator<_InputIter>::value,
     void
 >::type
 __split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last)
 @@ -245,10 +253,10 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIt
             __split_buffer __buf(__new_cap, 0, __a);
             for (pointer __p = __begin_; __p != __end_; ++__p, ++__buf.__end_)
                 __alloc_traits::construct(__buf.__alloc(),
-                        _VSTD::__to_raw_pointer(__buf.__end_), _VSTD::move(*__p));
+                        _VSTD::__to_address(__buf.__end_), _VSTD::move(*__p));
             swap(__buf);
         }
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
+        __alloc_traits::construct(__a, _VSTD::__to_address(this->__end_), *__first);
         ++this->__end_;
     }
 }
 @@ -257,16 +265,15 @@ template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
-    __is_forward_iterator<_ForwardIterator>::value,
+    __is_cpp17_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
 {
-    __alloc_rr& __a = this->__alloc();
+    _ConstructTransaction __tx(&this->__end_, std::distance(__first, __last));
-    for (; __first != __last; ++__first)
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, ++__first) {
-    {
+        __alloc_traits::construct(this->__alloc(),
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
+            _VSTD::__to_address(__tx.__pos_), *__first);
-        ++this->__end_;
     }
 }
 @@ -276,7 +283,7 @@ void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
 {
     while (__begin_ != __new_begin)
-        __alloc_traits::destroy(__alloc(), __to_raw_pointer(__begin_++));
+        __alloc_traits::destroy(__alloc(), __to_address(__begin_++));
 }
 template <class _Tp, class _Allocator>
 @@ -293,7 +300,7 @@ void
 __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
 {
     while (__new_last != __end_)
-        __alloc_traits::destroy(__alloc(), __to_raw_pointer(--__end_));
+        __alloc_traits::destroy(__alloc(), __to_address(--__end_));
 }
 template <class _Tp, class _Allocator>
 @@ -317,7 +324,7 @@ template <class _Tp, class _Allocator>
 inline
 __split_buffer<_Tp, _Allocator>::__split_buffer()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-    : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr)
+    : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __default_init_tag())
 {
 }
 @@ -361,7 +368,7 @@ __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a)
-    : __end_cap_(__second_tag(), __a)
+    : __end_cap_(nullptr, __a)
 {
     if (__a == __c.__alloc())
     {
 @@ -488,7 +495,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1), __x);
+    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1), __x);
     --__begin_;
 }
 @@ -519,7 +526,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1),
+    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1),
             _VSTD::move(__x));
     --__begin_;
 }
 @@ -552,7 +559,7 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_), __x);
+    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_), __x);
     ++__end_;
 }
 @@ -583,7 +590,7 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
+    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
             _VSTD::move(__x));
     ++__end_;
 }
 @@ -614,7 +621,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
             _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
+    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
                               _VSTD::forward<_Args>(__args)...);
     ++__end_;
 }

lib/libcxx/include/__string+140-52

...	@@ -31,11 +31,12 @@ struct char_traits	...	@@ -31,11 +31,12 @@ struct char_traits
31		31
32	static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);	32	static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
33	static constexpr size_t length(const char_type* s);	33	static constexpr size_t length(const char_type* s);
34	static constexpr const char_type*	34	static constexpr const char_type*
35	find(const char_type* s, size_t n, const char_type& a);	35	find(const char_type* s, size_t n, const char_type& a);
36	static char_type* move(char_type* s1, const char_type* s2, size_t n);	36
37	static char_type* copy(char_type* s1, const char_type* s2, size_t n);	37	static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n); // constexpr in C++20
38	static char_type* assign(char_type* s, size_t n, char_type a);	38	static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n); // constexpr in C++20
		39	static constexpr char_type* assign(char_type* s, size_t n, char_type a); // constexpr in C++20
39		40
40	static constexpr int_type not_eof(int_type c) noexcept;	41	static constexpr int_type not_eof(int_type c) noexcept;
41	static constexpr char_type to_char_type(int_type c) noexcept;	42	static constexpr char_type to_char_type(int_type c) noexcept;
...	@@ -93,11 +94,14 @@ struct _LIBCPP_TEMPLATE_VIS char_traits	...	@@ -93,11 +94,14 @@ struct _LIBCPP_TEMPLATE_VIS char_traits
93	size_t length(const char_type* __s);	94	size_t length(const char_type* __s);
94	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14	95	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
95	const char_type* find(const char_type* __s, size_t __n, const char_type& __a);	96	const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
96	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n);	97	static _LIBCPP_CONSTEXPR_AFTER_CXX17
		98	char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
97	_LIBCPP_INLINE_VISIBILITY	99	_LIBCPP_INLINE_VISIBILITY
98	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);	100	static _LIBCPP_CONSTEXPR_AFTER_CXX17
		101	char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
99	_LIBCPP_INLINE_VISIBILITY	102	_LIBCPP_INLINE_VISIBILITY
100	static char_type* assign(char_type* __s, size_t __n, char_type __a);	103	static _LIBCPP_CONSTEXPR_AFTER_CXX17
		104	char_type* assign(char_type* __s, size_t __n, char_type __a);
101		105
102	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT	106	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
103	{return eq_int_type(__c, eof()) ? ~eof() : __c;}	107	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
...	@@ -151,9 +155,10 @@ char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a	...	@@ -151,9 +155,10 @@ char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a
151	}	155	}
152		156
153	template <class _CharT>	157	template <class _CharT>
154	_CharT*	158	_LIBCPP_CONSTEXPR_AFTER_CXX17 _CharT*
155	char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)	159	char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
156	{	160	{
		161	if (__n == 0) return __s1;
157	char_type* __r = __s1;	162	char_type* __r = __s1;
158	if (__s1 < __s2)	163	if (__s1 < __s2)
159	{	164	{
...	@@ -171,7 +176,7 @@ char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)	...	@@ -171,7 +176,7 @@ char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
171	}	176	}
172		177
173	template <class _CharT>	178	template <class _CharT>
174	inline	179	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
175	_CharT*	180	_CharT*
176	char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)	181	char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
177	{	182	{
...	@@ -183,7 +188,7 @@ char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)	...	@@ -183,7 +188,7 @@ char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
183	}	188	}
184		189
185	template <class _CharT>	190	template <class _CharT>
186	inline	191	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
187	_CharT*	192	_CharT*
188	char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)	193	char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
189	{	194	{
...	@@ -193,6 +198,37 @@ char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)	...	@@ -193,6 +198,37 @@ char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
193	return __r;	198	return __r;
194	}	199	}
195		200
		201	// constexpr versions of move/copy/assign.
		202
		203	template <class _CharT>
		204	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		205	_CharT* __move_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
		206	{
		207	if (__n == 0) return __s1;
		208	if (__s1 < __s2) {
		209	_VSTD::copy(__s2, __s2 + __n, __s1);
		210	} else if (__s2 < __s1) {
		211	_VSTD::copy_backward(__s2, __s2 + __n, __s1 + __n);
		212	}
		213	return __s1;
		214	}
		215
		216	template <class _CharT>
		217	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		218	_CharT* __copy_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
		219	{
		220	_VSTD::copy_n(__s2, __n, __s1);
		221	return __s1;
		222	}
		223
		224	template <class _CharT>
		225	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		226	_CharT* __assign_constexpr(_CharT* __s, size_t __n, _CharT __a) _NOEXCEPT
		227	{
		228	_VSTD::fill_n(__s, __n, __a);
		229	return __s;
		230	}
		231
196	// char_traits<char>	232	// char_traits<char>
197		233
198	template <>	234	template <>
...	@@ -217,15 +253,28 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char>	...	@@ -217,15 +253,28 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char>
217	length(const char_type* __s) _NOEXCEPT {return __builtin_strlen(__s);}	253	length(const char_type* __s) _NOEXCEPT {return __builtin_strlen(__s);}
218	static _LIBCPP_CONSTEXPR_AFTER_CXX14	254	static _LIBCPP_CONSTEXPR_AFTER_CXX14
219	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;	255	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
220	static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	256	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
221	{return __n == 0 ? __s1 : (char_type*) memmove(__s1, __s2, __n);}	257	char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
222	static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	258	{
		259	return __libcpp_is_constant_evaluated()
		260	? __move_constexpr(__s1, __s2, __n)
		261	: __n == 0 ? __s1 : (char_type*)memmove(__s1, __s2, __n);
		262	}
		263	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		264	char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
223	{	265	{
224	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");	266	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
225	return __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);	267	return __libcpp_is_constant_evaluated()
		268	? __copy_constexpr(__s1, __s2, __n)
		269	: __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);
		270	}
		271	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		272	char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
		273	{
		274	return __libcpp_is_constant_evaluated()
		275	? __assign_constexpr(__s, __n, __a)
		276	: __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);
226	}	277	}
227	static inline char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
228	{return __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);}
229		278
230	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT	279	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
231	{return eq_int_type(__c, eof()) ? ~eof() : __c;}	280	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
...	@@ -307,16 +356,28 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>	...	@@ -307,16 +356,28 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
307	size_t length(const char_type* __s) _NOEXCEPT;	356	size_t length(const char_type* __s) _NOEXCEPT;
308	static _LIBCPP_CONSTEXPR_AFTER_CXX14	357	static _LIBCPP_CONSTEXPR_AFTER_CXX14
309	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;	358	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
310	static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	359	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
311	{return __n == 0 ? __s1 : (char_type*)wmemmove(__s1, __s2, __n);}	360	char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
312	static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	361	{
		362	return __libcpp_is_constant_evaluated()
		363	? __move_constexpr(__s1, __s2, __n)
		364	: __n == 0 ? __s1 : wmemmove(__s1, __s2, __n);
		365	}
		366	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		367	char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
313	{	368	{
314	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");	369	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
315	return __n == 0 ? __s1 : (char_type*)wmemcpy(__s1, __s2, __n);	370	return __libcpp_is_constant_evaluated()
		371	? __copy_constexpr(__s1, __s2, __n)
		372	: __n == 0 ? __s1 : wmemcpy(__s1, __s2, __n);
		373	}
		374	static inline _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		375	char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
		376	{
		377	return __libcpp_is_constant_evaluated()
		378	? __assign_constexpr(__s, __n, __a)
		379	: __n == 0 ? __s : wmemset(__s, __a, __n);
316	}	380	}
317	static inline char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
318	{return __n == 0 ? __s : (char_type*)wmemset(__s, __a, __n);}
319
320	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT	381	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
321	{return eq_int_type(__c, eof()) ? ~eof() : __c;}	382	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
322	static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT	383	static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
...	@@ -351,6 +412,18 @@ char_traits<wchar_t>::compare(const char_type* __s1, const char_type* __s2, size	...	@@ -351,6 +412,18 @@ char_traits<wchar_t>::compare(const char_type* __s1, const char_type* __s2, size
351	#endif	412	#endif
352	}	413	}
353		414
		415
		416	template <class _Traits>
		417	_LIBCPP_INLINE_VISIBILITY
		418	_LIBCPP_CONSTEXPR
		419	inline size_t __char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
		420	#if _LIBCPP_DEBUG_LEVEL >= 1
		421	return __s ? _Traits::length(__s) : (_VSTD::__libcpp_debug_function(_VSTD::__libcpp_debug_info(__FILE__, __LINE__, "p == nullptr", "null pointer pass to non-null argument of char_traits<...>::length")), 0);
		422	#else
		423	return _Traits::length(__s);
		424	#endif
		425	}
		426
354	inline _LIBCPP_CONSTEXPR_AFTER_CXX14	427	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
355	size_t	428	size_t
356	char_traits<wchar_t>::length(const char_type* __s) _NOEXCEPT	429	char_traits<wchar_t>::length(const char_type* __s) _NOEXCEPT
...	@@ -412,21 +485,34 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>	...	@@ -412,21 +485,34 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
412		485
413	static constexpr	486	static constexpr
414	size_t length(const char_type* __s) _NOEXCEPT;	487	size_t length(const char_type* __s) _NOEXCEPT;
415		488
416	_LIBCPP_INLINE_VISIBILITY static constexpr	489	_LIBCPP_INLINE_VISIBILITY static constexpr
417	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;	490	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
418		491
419	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	492	static _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
420	{return __n == 0 ? __s1 : (char_type*) memmove(__s1, __s2, __n);}	493	char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
421		494	{
422	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	495	return __libcpp_is_constant_evaluated()
		496	? __move_constexpr(__s1, __s2, __n)
		497	: __n == 0 ? __s1 : (char_type*)memmove(__s1, __s2, __n);
		498	}
		499
		500	static _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		501	char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
423	{	502	{
424	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");	503	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
425	return __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);	504	return __libcpp_is_constant_evaluated()
426	}	505	? __copy_constexpr(__s1, __s2, __n)
427		506	: __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);
428	static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT	507	}
429	{return __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);}	508
		509	static _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
		510	char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
		511	{
		512	return __libcpp_is_constant_evaluated()
		513	? __assign_constexpr(__s, __n, __a)
		514	: __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);
		515	}
430		516
431	static inline constexpr int_type not_eof(int_type __c) noexcept	517	static inline constexpr int_type not_eof(int_type __c) noexcept
432	{return eq_int_type(__c, eof()) ? ~eof() : __c;}	518	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
...	@@ -509,11 +595,11 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>	...	@@ -509,11 +595,11 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
509	size_t length(const char_type* __s) _NOEXCEPT;	595	size_t length(const char_type* __s) _NOEXCEPT;
510	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14	596	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
511	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;	597	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
512	_LIBCPP_INLINE_VISIBILITY	598	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
513	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;	599	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
514	_LIBCPP_INLINE_VISIBILITY	600	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
515	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;	601	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
516	_LIBCPP_INLINE_VISIBILITY	602	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
517	static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;	603	static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;
518		604
519	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT	605	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
...	@@ -565,10 +651,11 @@ char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& _	...	@@ -565,10 +651,11 @@ char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& _
565	return 0;	651	return 0;
566	}	652	}
567		653
568	inline	654	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
569	char16_t*	655	char16_t*
570	char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	656	char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
571	{	657	{
		658	if (__n == 0) return __s1;
572	char_type* __r = __s1;	659	char_type* __r = __s1;
573	if (__s1 < __s2)	660	if (__s1 < __s2)
574	{	661	{
...	@@ -585,7 +672,7 @@ char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n)	...	@@ -585,7 +672,7 @@ char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n)
585	return __r;	672	return __r;
586	}	673	}
587		674
588	inline	675	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
589	char16_t*	676	char16_t*
590	char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	677	char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
591	{	678	{
...	@@ -596,7 +683,7 @@ char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)	...	@@ -596,7 +683,7 @@ char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)
596	return __r;	683	return __r;
597	}	684	}
598		685
599	inline	686	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
600	char16_t*	687	char16_t*
601	char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT	688	char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
602	{	689	{
...	@@ -628,11 +715,11 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>	...	@@ -628,11 +715,11 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
628	size_t length(const char_type* __s) _NOEXCEPT;	715	size_t length(const char_type* __s) _NOEXCEPT;
629	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14	716	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
630	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;	717	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
631	_LIBCPP_INLINE_VISIBILITY	718	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
632	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;	719	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
633	_LIBCPP_INLINE_VISIBILITY	720	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
634	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;	721	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
635	_LIBCPP_INLINE_VISIBILITY	722	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
636	static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;	723	static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;
637		724
638	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT	725	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
...	@@ -684,10 +771,11 @@ char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& _	...	@@ -684,10 +771,11 @@ char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& _
684	return 0;	771	return 0;
685	}	772	}
686		773
687	inline	774	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
688	char32_t*	775	char32_t*
689	char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	776	char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
690	{	777	{
		778	if (__n == 0) return __s1;
691	char_type* __r = __s1;	779	char_type* __r = __s1;
692	if (__s1 < __s2)	780	if (__s1 < __s2)
693	{	781	{
...	@@ -704,7 +792,7 @@ char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n)	...	@@ -704,7 +792,7 @@ char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n)
704	return __r;	792	return __r;
705	}	793	}
706		794
707	inline	795	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
708	char32_t*	796	char32_t*
709	char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT	797	char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
710	{	798	{
...	@@ -715,7 +803,7 @@ char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)	...	@@ -715,7 +803,7 @@ char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)
715	return __r;	803	return __r;
716	}	804	}
717		805
718	inline	806	inline _LIBCPP_CONSTEXPR_AFTER_CXX17
719	char32_t*	807	char32_t*
720	char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT	808	char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
721	{	809	{
...	@@ -732,7 +820,7 @@ char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCE	...	@@ -732,7 +820,7 @@ char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCE
732	// __str_find	820	// __str_find
733	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>	821	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
734	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY	822	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
735	__str_find(const _CharT *__p, _SizeT __sz,	823	__str_find(const _CharT *__p, _SizeT __sz,
736	_CharT __c, _SizeT __pos) _NOEXCEPT	824	_CharT __c, _SizeT __pos) _NOEXCEPT
737	{	825	{
738	if (__pos >= __sz)	826	if (__pos >= __sz)
...	@@ -784,7 +872,7 @@ __search_substring(const _CharT __first1, const _CharT __last1,	...	@@ -784,7 +872,7 @@ __search_substring(const _CharT __first1, const _CharT __last1,
784		872
785	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>	873	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
786	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY	874	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
787	__str_find(const _CharT *__p, _SizeT __sz,	875	__str_find(const _CharT *__p, _SizeT __sz,
788	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT	876	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
789	{	877	{
790	if (__pos > __sz)	878	if (__pos > __sz)
...	@@ -806,7 +894,7 @@ __str_find(const _CharT *__p, _SizeT __sz,	...	@@ -806,7 +894,7 @@ __str_find(const _CharT *__p, _SizeT __sz,
806		894
807	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>	895	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
808	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY	896	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
809	__str_rfind(const _CharT *__p, _SizeT __sz,	897	__str_rfind(const _CharT *__p, _SizeT __sz,
810	_CharT __c, _SizeT __pos) _NOEXCEPT	898	_CharT __c, _SizeT __pos) _NOEXCEPT
811	{	899	{
812	if (__sz < 1)	900	if (__sz < 1)
...	@@ -825,7 +913,7 @@ __str_rfind(const _CharT *__p, _SizeT __sz,	...	@@ -825,7 +913,7 @@ __str_rfind(const _CharT *__p, _SizeT __sz,
825		913
826	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>	914	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
827	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY	915	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
828	__str_rfind(const _CharT *__p, _SizeT __sz,	916	__str_rfind(const _CharT *__p, _SizeT __sz,
829	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT	917	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
830	{	918	{
831	__pos = _VSTD::min(__pos, __sz);	919	__pos = _VSTD::min(__pos, __sz);
...	@@ -834,7 +922,7 @@ __str_rfind(const _CharT *__p, _SizeT __sz,	...	@@ -834,7 +922,7 @@ __str_rfind(const _CharT *__p, _SizeT __sz,
834	else	922	else
835	__pos = __sz;	923	__pos = __sz;
836	const _CharT* __r = _VSTD::__find_end(	924	const _CharT* __r = _VSTD::__find_end(
837	__p, __p + __pos, __s, __s + __n, _Traits::eq,	925	__p, __p + __pos, __s, __s + __n, _Traits::eq,
838	random_access_iterator_tag(), random_access_iterator_tag());	926	random_access_iterator_tag(), random_access_iterator_tag());
839	if (__n > 0 && __r == __p + __pos)	927	if (__n > 0 && __r == __p + __pos)
840	return __npos;	928	return __npos;
...	@@ -963,7 +1051,7 @@ struct __quoted_output_proxy	...	@@ -963,7 +1051,7 @@ struct __quoted_output_proxy
963		1051
964	__quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e)	1052	__quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e)
965	: __first(__f), __last(__l), __delim(__d), __escape(__e) {}	1053	: __first(__f), __last(__l), __delim(__d), __escape(__e) {}
966	// This would be a nice place for a string_ref	1054	// This would be a nice place for a string_ref
967	};	1055	};
968		1056
969	_LIBCPP_END_NAMESPACE_STD	1057	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__threading_support+236-29

...	@@ -23,16 +23,13 @@	...	@@ -23,16 +23,13 @@
23	# include <__external_threading>	23	# include <__external_threading>
24	#elif !defined(_LIBCPP_HAS_NO_THREADS)	24	#elif !defined(_LIBCPP_HAS_NO_THREADS)
25		25
26	typedef ::timespec __libcpp_timespec_t;
27
28	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)	26	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
29	# include <pthread.h>	27	# include <pthread.h>
30	# include <sched.h>	28	# include <sched.h>
		29	#elif defined(_LIBCPP_HAS_THREAD_API_C11)
		30	# include <threads.h>
31	#endif	31	#endif
32		32
33	_LIBCPP_PUSH_MACROS
34	#include <__undef_macros>
35
36	#if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \	33	#if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \
37	defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) \|\| \	34	defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) \|\| \
38	defined(_LIBCPP_HAS_THREAD_API_WIN32)	35	defined(_LIBCPP_HAS_THREAD_API_WIN32)
...	@@ -47,8 +44,16 @@ _LIBCPP_PUSH_MACROS	...	@@ -47,8 +44,16 @@ _LIBCPP_PUSH_MACROS
47	#define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS	44	#define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
48	#endif	45	#endif
49		46
		47	typedef ::timespec __libcpp_timespec_t;
		48	#endif // !defined(_LIBCPP_HAS_NO_THREADS)
		49
		50	_LIBCPP_PUSH_MACROS
		51	#include <__undef_macros>
		52
50	_LIBCPP_BEGIN_NAMESPACE_STD	53	_LIBCPP_BEGIN_NAMESPACE_STD
51		54
		55	#if !defined(_LIBCPP_HAS_NO_THREADS)
		56
52	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)	57	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
53	// Mutex	58	// Mutex
54	typedef pthread_mutex_t __libcpp_mutex_t;	59	typedef pthread_mutex_t __libcpp_mutex_t;
...	@@ -76,7 +81,36 @@ typedef pthread_t __libcpp_thread_t;	...	@@ -76,7 +81,36 @@ typedef pthread_t __libcpp_thread_t;
76	typedef pthread_key_t __libcpp_tls_key;	81	typedef pthread_key_t __libcpp_tls_key;
77		82
78	#define _LIBCPP_TLS_DESTRUCTOR_CC	83	#define _LIBCPP_TLS_DESTRUCTOR_CC
79	#else	84	#elif defined(_LIBCPP_HAS_THREAD_API_C11)
		85	// Mutex
		86	typedef mtx_t __libcpp_mutex_t;
		87	// mtx_t is a struct so using {} for initialization is valid.
		88	#define _LIBCPP_MUTEX_INITIALIZER {}
		89
		90	typedef mtx_t __libcpp_recursive_mutex_t;
		91
		92	// Condition Variable
		93	typedef cnd_t __libcpp_condvar_t;
		94	// cnd_t is a struct so using {} for initialization is valid.
		95	#define _LIBCPP_CONDVAR_INITIALIZER {}
		96
		97	// Execute once
		98	typedef once_flag __libcpp_exec_once_flag;
		99	#define _LIBCPP_EXEC_ONCE_INITIALIZER ONCE_FLAG_INIT
		100
		101	// Thread id
		102	typedef thrd_t __libcpp_thread_id;
		103
		104	// Thread
		105	#define _LIBCPP_NULL_THREAD 0U
		106
		107	typedef thrd_t __libcpp_thread_t;
		108
		109	// Thread Local Storage
		110	typedef tss_t __libcpp_tls_key;
		111
		112	#define _LIBCPP_TLS_DESTRUCTOR_CC
		113	#elif !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
80	// Mutex	114	// Mutex
81	typedef void* __libcpp_mutex_t;	115	typedef void* __libcpp_mutex_t;
82	#define _LIBCPP_MUTEX_INITIALIZER 0	116	#define _LIBCPP_MUTEX_INITIALIZER 0
...	@@ -109,8 +143,9 @@ typedef void* __libcpp_thread_t;	...	@@ -109,8 +143,9 @@ typedef void* __libcpp_thread_t;
109	typedef long __libcpp_tls_key;	143	typedef long __libcpp_tls_key;
110		144
111	#define _LIBCPP_TLS_DESTRUCTOR_CC __stdcall	145	#define _LIBCPP_TLS_DESTRUCTOR_CC __stdcall
112	#endif	146	#endif // !defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
113		147
		148	#if !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
114	// Mutex	149	// Mutex
115	_LIBCPP_THREAD_ABI_VISIBILITY	150	_LIBCPP_THREAD_ABI_VISIBILITY
116	int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m);	151	int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m);
...	@@ -205,9 +240,38 @@ void *__libcpp_tls_get(__libcpp_tls_key __key);	...	@@ -205,9 +240,38 @@ void *__libcpp_tls_get(__libcpp_tls_key __key);
205	_LIBCPP_THREAD_ABI_VISIBILITY	240	_LIBCPP_THREAD_ABI_VISIBILITY
206	int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);	241	int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);
207		242
		243	#endif // !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
		244
208	#if (!defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \	245	#if (!defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \
209	defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)) && \	246	defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL))
210	defined(_LIBCPP_HAS_THREAD_API_PTHREAD)	247
		248	namespace __thread_detail {
		249
		250	inline __libcpp_timespec_t __convert_to_timespec(const chrono::nanoseconds& __ns)
		251	{
		252	using namespace chrono;
		253	seconds __s = duration_cast<seconds>(__ns);
		254	__libcpp_timespec_t __ts;
		255	typedef decltype(__ts.tv_sec) __ts_sec;
		256	const __ts_sec __ts_sec_max = numeric_limits<__ts_sec>::max();
		257
		258	if (__s.count() < __ts_sec_max)
		259	{
		260	__ts.tv_sec = static_cast<__ts_sec>(__s.count());
		261	__ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count());
		262	}
		263	else
		264	{
		265	__ts.tv_sec = __ts_sec_max;
		266	__ts.tv_nsec = 999999999; // (10^9 - 1)
		267	}
		268
		269	return __ts;
		270	}
		271
		272	}
		273
		274	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
211		275
212	int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)	276	int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
213	{	277	{
...	@@ -357,23 +421,7 @@ void __libcpp_thread_yield()	...	@@ -357,23 +421,7 @@ void __libcpp_thread_yield()
357		421
358	void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)	422	void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
359	{	423	{
360	using namespace chrono;	424	__libcpp_timespec_t __ts = __thread_detail::__convert_to_timespec(__ns);
361	seconds __s = duration_cast<seconds>(__ns);
362	__libcpp_timespec_t __ts;
363	typedef decltype(__ts.tv_sec) ts_sec;
364	_LIBCPP_CONSTEXPR ts_sec __ts_sec_max = numeric_limits<ts_sec>::max();
365
366	if (__s.count() < __ts_sec_max)
367	{
368	__ts.tv_sec = static_cast<ts_sec>(__s.count());
369	__ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count());
370	}
371	else
372	{
373	__ts.tv_sec = __ts_sec_max;
374	__ts.tv_nsec = 999999999; // (10^9 - 1)
375	}
376
377	while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR);	425	while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR);
378	}	426	}
379		427
...	@@ -393,6 +441,165 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)	...	@@ -393,6 +441,165 @@ int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
393	return pthread_setspecific(__key, __p);	441	return pthread_setspecific(__key, __p);
394	}	442	}
395		443
		444	#elif defined(_LIBCPP_HAS_THREAD_API_C11)
		445
		446	int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
		447	{
		448	return mtx_init(__m, mtx_plain \| mtx_recursive) == thrd_success ? 0 : EINVAL;
		449	}
		450
		451	int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
		452	{
		453	return mtx_lock(__m) == thrd_success ? 0 : EINVAL;
		454	}
		455
		456	bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
		457	{
		458	return mtx_trylock(__m) == thrd_success;
		459	}
		460
		461	int __libcpp_recursive_mutex_unlock(__libcpp_mutex_t *__m)
		462	{
		463	return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;
		464	}
		465
		466	int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
		467	{
		468	mtx_destroy(__m);
		469	return 0;
		470	}
		471
		472	int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
		473	{
		474	return mtx_lock(__m) == thrd_success ? 0 : EINVAL;
		475	}
		476
		477	bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
		478	{
		479	return mtx_trylock(__m) == thrd_success;
		480	}
		481
		482	int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
		483	{
		484	return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;
		485	}
		486
		487	int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
		488	{
		489	mtx_destroy(__m);
		490	return 0;
		491	}
		492
		493	// Condition Variable
		494	int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
		495	{
		496	return cnd_signal(__cv) == thrd_success ? 0 : EINVAL;
		497	}
		498
		499	int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
		500	{
		501	return cnd_broadcast(__cv) == thrd_success ? 0 : EINVAL;
		502	}
		503
		504	int __libcpp_condvar_wait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m)
		505	{
		506	return cnd_wait(__cv, __m) == thrd_success ? 0 : EINVAL;
		507	}
		508
		509	int __libcpp_condvar_timedwait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m,
		510	timespec *__ts)
		511	{
		512	int __ec = cnd_timedwait(__cv, __m, __ts);
		513	return __ec == thrd_timedout ? ETIMEDOUT : __ec;
		514	}
		515
		516	int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
		517	{
		518	cnd_destroy(__cv);
		519	return 0;
		520	}
		521
		522	// Execute once
		523	int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
		524	void (*init_routine)(void)) {
		525	::call_once(flag, init_routine);
		526	return 0;
		527	}
		528
		529	// Thread id
		530	// Returns non-zero if the thread ids are equal, otherwise 0
		531	bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)
		532	{
		533	return thrd_equal(t1, t2) != 0;
		534	}
		535
		536	// Returns non-zero if t1 < t2, otherwise 0
		537	bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)
		538	{
		539	return t1 < t2;
		540	}
		541
		542	// Thread
		543	bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
		544	return *__t == 0;
		545	}
		546
		547	int __libcpp_thread_create(__libcpp_thread_t __t, void (__func)(void ),
		548	void *__arg)
		549	{
		550	int __ec = thrd_create(__t, reinterpret_cast<thrd_start_t>(__func), __arg);
		551	return __ec == thrd_nomem ? ENOMEM : __ec;
		552	}
		553
		554	__libcpp_thread_id __libcpp_thread_get_current_id()
		555	{
		556	return thrd_current();
		557	}
		558
		559	__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
		560	{
		561	return *__t;
		562	}
		563
		564	int __libcpp_thread_join(__libcpp_thread_t *__t)
		565	{
		566	return thrd_join(*__t, nullptr) == thrd_success ? 0 : EINVAL;
		567	}
		568
		569	int __libcpp_thread_detach(__libcpp_thread_t *__t)
		570	{
		571	return thrd_detach(*__t) == thrd_success ? 0 : EINVAL;
		572	}
		573
		574	void __libcpp_thread_yield()
		575	{
		576	thrd_yield();
		577	}
		578
		579	void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
		580	{
		581	__libcpp_timespec_t __ts = __thread_detail::__convert_to_timespec(__ns);
		582	thrd_sleep(&__ts, nullptr);
		583	}
		584
		585	// Thread local storage
		586	int __libcpp_tls_create(__libcpp_tls_key __key, void (__at_exit)(void *))
		587	{
		588	return tss_create(__key, __at_exit) == thrd_success ? 0 : EINVAL;
		589	}
		590
		591	void *__libcpp_tls_get(__libcpp_tls_key __key)
		592	{
		593	return tss_get(__key);
		594	}
		595
		596	int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
		597	{
		598	return tss_set(__key, __p) == thrd_success ? 0 : EINVAL;
		599	}
		600
		601	#endif
		602
396	#endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL \|\| _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL	603	#endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL \|\| _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL
397		604
398	class _LIBCPP_TYPE_VIS thread;	605	class _LIBCPP_TYPE_VIS thread;
...	@@ -447,7 +654,7 @@ public:	...	@@ -447,7 +654,7 @@ public:
447		654
448	_LIBCPP_INLINE_VISIBILITY	655	_LIBCPP_INLINE_VISIBILITY
449	void __reset() { __id_ = 0; }	656	void __reset() { __id_ = 0; }
450		657
451	template<class _CharT, class _Traits>	658	template<class _CharT, class _Traits>
452	friend	659	friend
453	_LIBCPP_INLINE_VISIBILITY	660	_LIBCPP_INLINE_VISIBILITY
...	@@ -475,10 +682,10 @@ get_id() _NOEXCEPT	...	@@ -475,10 +682,10 @@ get_id() _NOEXCEPT
475		682
476	} // this_thread	683	} // this_thread
477		684
		685	#endif // !_LIBCPP_HAS_NO_THREADS
		686
478	_LIBCPP_END_NAMESPACE_STD	687	_LIBCPP_END_NAMESPACE_STD
479		688
480	_LIBCPP_POP_MACROS	689	_LIBCPP_POP_MACROS
481		690
482	#endif // !_LIBCPP_HAS_NO_THREADS
483
484	#endif // _LIBCPP_THREADING_SUPPORT	691	#endif // _LIBCPP_THREADING_SUPPORT

lib/libcxx/include/__tree+10-7

lib/libcxx/include/__tuple+3-2

...	@@ -477,8 +477,9 @@ using __tuple_like_with_size _LIBCPP_NODEBUG_TYPE = __tuple_like_with_size_imp<	...	@@ -477,8 +477,9 @@ using __tuple_like_with_size _LIBCPP_NODEBUG_TYPE = __tuple_like_with_size_imp<
477	>;	477	>;
478		478
479	struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {	479	struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
480	template <class ...>	480
481	static constexpr bool __enable_default() { return false; }	481	static constexpr bool __enable_explicit_default() { return false; }
		482	static constexpr bool __enable_implicit_default() { return false; }
482	template <class ...>	483	template <class ...>
483	static constexpr bool __enable_explicit() { return false; }	484	static constexpr bool __enable_explicit() { return false; }
484	template <class ...>	485	template <class ...>

lib/libcxx/include/algorithm+73-41

 @@ -167,20 +167,20 @@ template <class ForwardIterator, class Size, class T, class BinaryPredicate>
              Size count, const T& value, BinaryPredicate pred);
 template <class InputIterator, class OutputIterator>
-    OutputIterator
+    constexpr OutputIterator      // constexpr in C++20
     copy(InputIterator first, InputIterator last, OutputIterator result);
 template<class InputIterator, class OutputIterator, class Predicate>
-    OutputIterator
+    constexpr OutputIterator      // constexpr in C++20
     copy_if(InputIterator first, InputIterator last,
             OutputIterator result, Predicate pred);
 template<class InputIterator, class Size, class OutputIterator>
-    OutputIterator
+    constexpr OutputIterator      // constexpr in C++20
     copy_n(InputIterator first, Size n, OutputIterator result);
 template <class BidirectionalIterator1, class BidirectionalIterator2>
-    BidirectionalIterator2
+    constexpr BidirectionalIterator2      // constexpr in C++20
     copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
 @@ -1631,7 +1631,7 @@ search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const
 // copy
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _Iter
 __unwrap_iter(_Iter __i)
 {
 @@ -1639,7 +1639,7 @@ __unwrap_iter(_Iter __i)
 }
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     is_trivially_copy_assignable<_Tp>::value,
 @@ -1693,15 +1693,23 @@ __unwrap_iter(__wrap_iter<_Tp*> __i)
 #endif  // _LIBCPP_DEBUG_LEVEL < 2
 template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
-__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+__copy_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     for (; __first != __last; ++__first, (void) ++__result)
         *__result = *__first;
     return __result;
 }
+template <class _InputIterator, class _OutputIterator>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
+__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+{
+    return __copy_constexpr(__first, __last, __result);
+}
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 @@ -1719,25 +1727,39 @@ __copy(_Tp* __first, _Tp* __last, _Up* __result)
 }
 template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
 _OutputIterator
 copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
-    return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    if (__libcpp_is_constant_evaluated()) {
+        return _VSTD::__copy_constexpr(
+            __unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    } else {
+        return _VSTD::__copy(
+            __unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    }
 }
 // copy_backward
 template <class _BidirectionalIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
-__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
+__copy_backward_constexpr(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
 {
     while (__first != __last)
         *--__result = *--__last;
     return __result;
 }
+template <class _BidirectionalIterator, class _OutputIterator>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
+__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
+{
+    return __copy_backward_constexpr(__first, __last, __result);
+}
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 @@ -1758,20 +1780,26 @@ __copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
 }
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
 _BidirectionalIterator2
 copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    return _VSTD::__copy_backward(__unwrap_iter(__first),
+    if (__libcpp_is_constant_evaluated()) {
-                                  __unwrap_iter(__last),
+        return _VSTD::__copy_backward_constexpr(__unwrap_iter(__first),
-                                  __unwrap_iter(__result));
+                                                __unwrap_iter(__last),
+                                                __unwrap_iter(__result));
+    } else {
+        return _VSTD::__copy_backward(__unwrap_iter(__first),
+                                      __unwrap_iter(__last),
+                                      __unwrap_iter(__result));
+    }
 }
 // copy_if
 template<class _InputIterator, class _OutputIterator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 copy_if(_InputIterator __first, _InputIterator __last,
         _OutputIterator __result, _Predicate __pred)
 @@ -1790,11 +1818,11 @@ copy_if(_InputIterator __first, _InputIterator __last,
 // copy_n
 template<class _InputIterator, class _Size, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
 typename enable_if
 <
-    __is_input_iterator<_InputIterator>::value &&
+    __is_cpp17_input_iterator<_InputIterator>::value &&
-   !__is_random_access_iterator<_InputIterator>::value,
+   !__is_cpp17_random_access_iterator<_InputIterator>::value,
     _OutputIterator
 >::type
 copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 @@ -1816,10 +1844,10 @@ copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 }
 template<class _InputIterator, class _Size, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
 typename enable_if
 <
-    __is_random_access_iterator<_InputIterator>::value,
+    __is_cpp17_random_access_iterator<_InputIterator>::value,
     _OutputIterator
 >::type
 copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 @@ -2492,7 +2520,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _ForwardIterator
 min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
 {
-    static_assert(__is_forward_iterator<_ForwardIterator>::value,
+    static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
         "std::min_element requires a ForwardIterator");
     if (__first != __last)
     {
 @@ -2564,7 +2592,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _ForwardIterator
 max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
 {
-    static_assert(__is_forward_iterator<_ForwardIterator>::value,
+    static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
         "std::max_element requires a ForwardIterator");
     if (__first != __last)
     {
 @@ -2659,7 +2687,7 @@ _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX11
 std::pair<_ForwardIterator, _ForwardIterator>
 minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
 {
-  static_assert(__is_forward_iterator<_ForwardIterator>::value,
+  static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
         "std::minmax_element requires a ForwardIterator");
   std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first);
   if (__first != __last)
 @@ -3117,10 +3145,10 @@ _SampleIterator __sample(_PopulationIterator __first,
                          input_iterator_tag) {
   _Distance __k = 0;
-  for (; __first != __last && __k < __n; ++__first, (void)++__k)
+  for (; __first != __last && __k < __n; ++__first, (void) ++__k)
     __output_iter[__k] = *__first;
   _Distance __sz = __k;
-  for (; __first != __last; ++__first, (void)++__k) {
+  for (; __first != __last; ++__first, (void) ++__k) {
     _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g);
     if (__r < __sz)
       __output_iter[__r] = *__first;
 @@ -3158,8 +3186,8 @@ _SampleIterator __sample(_PopulationIterator __first,
         _PopCategory;
   typedef typename iterator_traits<_PopulationIterator>::difference_type
         _Difference;
-  static_assert(__is_forward_iterator<_PopulationIterator>::value ||
+  static_assert(__is_cpp17_forward_iterator<_PopulationIterator>::value ||
-                __is_random_access_iterator<_SampleIterator>::value,
+                __is_cpp17_random_access_iterator<_SampleIterator>::value,
                 "SampleIterator must meet the requirements of RandomAccessIterator");
   typedef typename common_type<_Distance, _Difference>::type _CommonType;
   _LIBCPP_ASSERT(__n >= 0, "N must be a positive number.");
 @@ -3190,7 +3218,7 @@ template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
     if (__d > 1)
     {
         _Dp __uid;
-        for (--__last, --__d; __first < __last; ++__first, --__d)
+        for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
         {
             difference_type __i = __uid(__g, _Pp(0, __d));
             if (__i != difference_type(0))
 @@ -3373,7 +3401,7 @@ __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate
         // All trues now at start of range, all falses in buffer
         // Move falses back into range, but don't mess up __first which points to first false
         __i = __first;
-        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
+        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
             *__i = _VSTD::move(*__t2);
         // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
         return __first;
 @@ -3505,7 +3533,7 @@ __stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last
         __i = ++__first;
         // All trues now at start of range, all falses in buffer
         // Move falses back into range, but don't mess up __first which points to first false
-        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
+        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
             *__i = _VSTD::move(*__t2);
         // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
         return __first;
 @@ -4382,7 +4410,7 @@ merge(_InputIterator1 __first1, _InputIterator1 __last1,
 {
     typedef typename iterator_traits<_InputIterator1>::value_type __v1;
     typedef typename iterator_traits<_InputIterator2>::value_type __v2;
-    return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
+    return _VSTD::merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
 }
 // inplace_merge
 @@ -4428,14 +4456,14 @@ __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator
     if (__len1 <= __len2)
     {
         value_type* __p = __buff;
-        for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, ++__p)
+        for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, (void) ++__p)
             ::new(__p) value_type(_VSTD::move(*__i));
         __half_inplace_merge(__buff, __p, __middle, __last, __first, __comp);
     }
     else
     {
         value_type* __p = __buff;
-        for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), (void) ++__i, ++__p)
+        for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), (void) ++__i, (void) ++__p)
             ::new(__p) value_type(_VSTD::move(*__i));
         typedef reverse_iterator<_BidirectionalIterator> _RBi;
         typedef reverse_iterator<value_type*> _Rv;
 @@ -4575,14 +4603,14 @@ __merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
     {
         if (__first1 == __last1)
         {
-            for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0))
+            for (; __first2 != __last2; ++__first2, ++__result, (void) __d.__incr((value_type*)0))
                 ::new (__result) value_type(_VSTD::move(*__first2));
             __h.release();
             return;
         }
         if (__first2 == __last2)
         {
-            for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0))
+            for (; __first1 != __last1; ++__first1, ++__result, (void) __d.__incr((value_type*)0))
                 ::new (__result) value_type(_VSTD::move(*__first1));
             __h.release();
             return;
 @@ -4612,7 +4640,7 @@ __merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
     {
         if (__first2 == __last2)
         {
-            for (; __first1 != __last1; ++__first1, ++__result)
+            for (; __first1 != __last1; ++__first1, (void) ++__result)
                 *__result = _VSTD::move(*__first1);
             return;
         }
 @@ -4627,7 +4655,7 @@ __merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
             ++__first1;
         }
     }
-    for (; __first2 != __last2; ++__first2, ++__result)
+    for (; __first2 != __last2; ++__first2, (void) ++__result)
         *__result = _VSTD::move(*__first2);
 }
 @@ -4995,7 +5023,7 @@ void
 __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    for (difference_type __n = __last - __first; __n > 1; --__last, --__n)
+    for (difference_type __n = __last - __first; __n > 1; --__last, (void) --__n)
         __pop_heap<_Compare>(__first, __last, __comp, __n);
 }
 @@ -5065,7 +5093,7 @@ __partial_sort_copy(_InputIterator __first, _InputIterator __last,
     _RandomAccessIterator __r = __result_first;
     if (__r != __result_last)
     {
-        for (; __first != __last && __r != __result_last; (void) ++__first, ++__r)
+        for (; __first != __last && __r != __result_last; ++__first, (void) ++__r)
             *__r = *__first;
         __make_heap<_Compare>(__result_first, __r, __comp);
         typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first;
 @@ -5678,4 +5706,8 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_POP_MACROS
+#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
+#   include <__pstl_algorithm>
+#endif
 #endif  // _LIBCPP_ALGORITHM

lib/libcxx/include/atomic+1-1

...	@@ -920,7 +920,7 @@ struct __cxx_atomic_base_impl {	...	@@ -920,7 +920,7 @@ struct __cxx_atomic_base_impl {
920	#endif // _LIBCPP_CXX03_LANG	920	#endif // _LIBCPP_CXX03_LANG
921	_LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT	921	_LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
922	: __a_value(value) {}	922	: __a_value(value) {}
923	_Atomic(_Tp) __a_value;	923	_LIBCPP_DISABLE_EXTENSION_WARNING _Atomic(_Tp) __a_value;
924	};	924	};
925		925
926	#define __cxx_atomic_is_lock_free(__s) __c11_atomic_is_lock_free(__s)	926	#define __cxx_atomic_is_lock_free(__s) __c11_atomic_is_lock_free(__s)

lib/libcxx/include/bit+22-1

...	@@ -42,6 +42,13 @@ namespace std {	...	@@ -42,6 +42,13 @@ namespace std {
42	template<class T>	42	template<class T>
43	constexpr int popcount(T x) noexcept; // C++20	43	constexpr int popcount(T x) noexcept; // C++20
44		44
		45	// 20.15.9, endian
		46	enum class endian {
		47	little = see below, // C++20
		48	big = see below, // C++20
		49	native = see below // C++20
		50	};
		51
45	} // namespace std	52	} // namespace std
46		53
47	*/	54	*/
...	@@ -343,7 +350,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR	...	@@ -343,7 +350,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
343	bool __ispow2(_Tp __t) _NOEXCEPT	350	bool __ispow2(_Tp __t) _NOEXCEPT
344	{	351	{
345	static_assert(__bitop_unsigned_integer<_Tp>::value, "__ispow2 requires unsigned");	352	static_assert(__bitop_unsigned_integer<_Tp>::value, "__ispow2 requires unsigned");
346	return __t != 0 && (((__t & (__t - 1)) == 0));	353	return __t != 0 && (((__t & (__t - 1)) == 0));
347	}	354	}
348		355
349		356
...	@@ -456,6 +463,20 @@ log2p1(_Tp __t) noexcept	...	@@ -456,6 +463,20 @@ log2p1(_Tp __t) noexcept
456	return __t == 0 ? 0 : __bit_log2(__t) + 1;	463	return __t == 0 ? 0 : __bit_log2(__t) + 1;
457	}	464	}
458		465
		466
		467	enum class endian
		468	{
		469	little = 0xDEAD,
		470	big = 0xFACE,
		471	#if defined(_LIBCPP_LITTLE_ENDIAN)
		472	native = little
		473	#elif defined(_LIBCPP_BIG_ENDIAN)
		474	native = big
		475	#else
		476	native = 0xCAFE
		477	#endif
		478	};
		479
459	#endif // _LIBCPP_STD_VER > 17	480	#endif // _LIBCPP_STD_VER > 17
460		481
461	_LIBCPP_END_NAMESPACE_STD	482	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/chrono+131-15

...	@@ -612,13 +612,43 @@ constexpr year_month_weekday_last	...	@@ -612,13 +612,43 @@ constexpr year_month_weekday_last
612	constexpr year_month_weekday_last	612	constexpr year_month_weekday_last
613	operator/(const month_weekday_last& mwdl, int y) noexcept;	613	operator/(const month_weekday_last& mwdl, int y) noexcept;
614		614
615	// 25.9, class template time_of_day // C++20	615	// 26.9, class template hh_mm_ss
616	template<class Duration> class time_of_day;	616	template <class Duration>
		617	class hh_mm_ss
		618	{
		619	bool is_neg; // exposition only
		620	chrono::hours h; // exposition only
		621	chrono::minutes m; // exposition only
		622	chrono::seconds s; // exposition only
		623	precision ss; // exposition only
		624
		625	public:
		626	static unsigned constexpr fractional_width = see below;
		627	using precision = see below;
		628
		629	constexpr hh_mm_ss() noexcept : hh_mm_ss{Duration::zero()} {}
		630	constexpr explicit hh_mm_ss(Duration d) noexcept;
		631
		632	constexpr bool is_negative() const noexcept;
		633	constexpr chrono::hours hours() const noexcept;
		634	constexpr chrono::minutes minutes() const noexcept;
		635	constexpr chrono::seconds seconds() const noexcept;
		636	constexpr precision subseconds() const noexcept;
		637
		638	constexpr explicit operator precision() const noexcept;
		639	constexpr precision to_duration() const noexcept;
		640	};
		641
		642	template <class charT, class traits, class Duration>
		643	basic_ostream<charT, traits>&
		644	operator<<(basic_ostream<charT, traits>& os, hh_mm_ss<Duration> const& hms);
		645
		646	// 26.10, 12/24 hour functions
		647	constexpr bool is_am(hours const& h) noexcept;
		648	constexpr bool is_pm(hours const& h) noexcept;
		649	constexpr hours make12(const hours& h) noexcept;
		650	constexpr hours make24(const hours& h, bool is_pm) noexcept;
617		651
618	template<> class time_of_day<hours>;
619	template<> class time_of_day<minutes>;
620	template<> class time_of_day<seconds>;
621	template<class Rep, class Period> class time_of_day<duration<Rep, Period>>;
622		652
623	// 25.10.2, time zone database // C++20	653	// 25.10.2, time zone database // C++20
624	struct tzdb;	654	struct tzdb;
...	@@ -1428,7 +1458,7 @@ typename enable_if	...	@@ -1428,7 +1458,7 @@ typename enable_if
1428	>::type	1458	>::type
1429	abs(duration<_Rep, _Period> __d)	1459	abs(duration<_Rep, _Period> __d)
1430	{	1460	{
1431	return __d >= __d.zero() ? __d : -__d;	1461	return __d >= __d.zero() ? +__d : -__d;
1432	}	1462	}
1433	#endif	1463	#endif
1434		1464
...	@@ -1810,7 +1840,7 @@ private:	...	@@ -1810,7 +1840,7 @@ private:
1810	unsigned char __wd;	1840	unsigned char __wd;
1811	public:	1841	public:
1812	weekday() = default;	1842	weekday() = default;
1813	inline explicit constexpr weekday(unsigned __val) noexcept : __wd(static_cast<unsigned char>(__val)) {}	1843	inline explicit constexpr weekday(unsigned __val) noexcept : __wd(static_cast<unsigned char>(__val == 7 ? 0 : __val)) {}
1814	inline constexpr weekday(const sys_days& __sysd) noexcept	1844	inline constexpr weekday(const sys_days& __sysd) noexcept
1815	: __wd(__weekday_from_days(__sysd.time_since_epoch().count())) {}	1845	: __wd(__weekday_from_days(__sysd.time_since_epoch().count())) {}
1816	inline explicit constexpr weekday(const local_days& __locd) noexcept	1846	inline explicit constexpr weekday(const local_days& __locd) noexcept
...	@@ -1822,11 +1852,13 @@ public:	...	@@ -1822,11 +1852,13 @@ public:
1822	inline constexpr weekday operator--(int) noexcept { weekday __tmp = this; --(this); return __tmp; }	1852	inline constexpr weekday operator--(int) noexcept { weekday __tmp = this; --(this); return __tmp; }
1823	constexpr weekday& operator+=(const days& __dd) noexcept;	1853	constexpr weekday& operator+=(const days& __dd) noexcept;
1824	constexpr weekday& operator-=(const days& __dd) noexcept;	1854	constexpr weekday& operator-=(const days& __dd) noexcept;
1825	inline explicit constexpr operator unsigned() const noexcept { return __wd; }	1855	inline constexpr unsigned c_encoding() const noexcept { return __wd; }
		1856	inline constexpr unsigned iso_encoding() const noexcept { return __wd == 0u ? 7 : __wd; }
1826	inline constexpr bool ok() const noexcept { return __wd <= 6; }	1857	inline constexpr bool ok() const noexcept { return __wd <= 6; }
1827	constexpr weekday_indexed operator[](unsigned __index) const noexcept;	1858	constexpr weekday_indexed operator[](unsigned __index) const noexcept;
1828	constexpr weekday_last operator[](last_spec) const noexcept;	1859	constexpr weekday_last operator[](last_spec) const noexcept;
1829		1860
		1861	// TODO: Make private?
1830	static constexpr unsigned char __weekday_from_days(int __days) noexcept;	1862	static constexpr unsigned char __weekday_from_days(int __days) noexcept;
1831	};	1863	};
1832		1864
...	@@ -1842,7 +1874,7 @@ unsigned char weekday::__weekday_from_days(int __days) noexcept	...	@@ -1842,7 +1874,7 @@ unsigned char weekday::__weekday_from_days(int __days) noexcept
1842		1874
1843	inline constexpr	1875	inline constexpr
1844	bool operator==(const weekday& __lhs, const weekday& __rhs) noexcept	1876	bool operator==(const weekday& __lhs, const weekday& __rhs) noexcept
1845	{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }	1877	{ return __lhs.c_encoding() == __rhs.c_encoding(); }
1846		1878
1847	inline constexpr	1879	inline constexpr
1848	bool operator!=(const weekday& __lhs, const weekday& __rhs) noexcept	1880	bool operator!=(const weekday& __lhs, const weekday& __rhs) noexcept
...	@@ -1850,7 +1882,7 @@ bool operator!=(const weekday& __lhs, const weekday& __rhs) noexcept	...	@@ -1850,7 +1882,7 @@ bool operator!=(const weekday& __lhs, const weekday& __rhs) noexcept
1850		1882
1851	inline constexpr	1883	inline constexpr
1852	bool operator< (const weekday& __lhs, const weekday& __rhs) noexcept	1884	bool operator< (const weekday& __lhs, const weekday& __rhs) noexcept
1853	{ return static_cast<unsigned>(__lhs) < static_cast<unsigned>(__rhs); }	1885	{ return __lhs.c_encoding() < __rhs.c_encoding(); }
1854		1886
1855	inline constexpr	1887	inline constexpr
1856	bool operator> (const weekday& __lhs, const weekday& __rhs) noexcept	1888	bool operator> (const weekday& __lhs, const weekday& __rhs) noexcept
...	@@ -1866,7 +1898,7 @@ bool operator>=(const weekday& __lhs, const weekday& __rhs) noexcept	...	@@ -1866,7 +1898,7 @@ bool operator>=(const weekday& __lhs, const weekday& __rhs) noexcept
1866		1898
1867	constexpr weekday operator+(const weekday& __lhs, const days& __rhs) noexcept	1899	constexpr weekday operator+(const weekday& __lhs, const days& __rhs) noexcept
1868	{	1900	{
1869	auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + __rhs.count();	1901	auto const __mu = static_cast<long long>(__lhs.c_encoding()) + __rhs.count();
1870	auto const __yr = (__mu >= 0 ? __mu : __mu - 6) / 7;	1902	auto const __yr = (__mu >= 0 ? __mu : __mu - 6) / 7;
1871	return weekday{static_cast<unsigned>(__mu - __yr * 7)};	1903	return weekday{static_cast<unsigned>(__mu - __yr * 7)};
1872	}	1904	}
...	@@ -1879,7 +1911,7 @@ constexpr weekday operator-(const weekday& __lhs, const days& __rhs) noexcept	...	@@ -1879,7 +1911,7 @@ constexpr weekday operator-(const weekday& __lhs, const days& __rhs) noexcept
1879		1911
1880	constexpr days operator-(const weekday& __lhs, const weekday& __rhs) noexcept	1912	constexpr days operator-(const weekday& __lhs, const weekday& __rhs) noexcept
1881	{	1913	{
1882	const int __wdu = static_cast<unsigned>(__lhs) - static_cast<unsigned>(__rhs);	1914	const int __wdu = __lhs.c_encoding() - __rhs.c_encoding();
1883	const int __wk = (__wdu >= 0 ? __wdu : __wdu-6) / 7;	1915	const int __wk = (__wdu >= 0 ? __wdu : __wdu-6) / 7;
1884	return days{__wdu - __wk * 7};	1916	return days{__wdu - __wk * 7};
1885	}	1917	}
...	@@ -2537,8 +2569,13 @@ public:	...	@@ -2537,8 +2569,13 @@ public:
2537	inline constexpr bool ok() const noexcept	2569	inline constexpr bool ok() const noexcept
2538	{	2570	{
2539	if (!__y.ok() \|\| !__m.ok() \|\| !__wdi.ok()) return false;	2571	if (!__y.ok() \|\| !__m.ok() \|\| !__wdi.ok()) return false;
2540	// TODO: make sure it's a valid date	2572	if (__wdi.index() <= 4) return true;
2541	return true;	2573	auto __nth_weekday_day =
		2574	__wdi.weekday() -
		2575	chrono::weekday{static_cast<sys_days>(__y / __m / 1)} +
		2576	days{(__wdi.index() - 1) * 7 + 1};
		2577	return static_cast<unsigned>(__nth_weekday_day.count()) <=
		2578	static_cast<unsigned>((__y / __m / last).day());
2542	}	2579	}
2543		2580
2544	static constexpr year_month_weekday __from_days(days __d) noexcept;	2581	static constexpr year_month_weekday __from_days(days __d) noexcept;
...	@@ -2715,6 +2752,84 @@ inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(co	...	@@ -2715,6 +2752,84 @@ inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(co
2715	inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& __dy) noexcept { this = this + __dy; return *this; }	2752	inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& __dy) noexcept { this = this + __dy; return *this; }
2716	inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& __dy) noexcept { this = this - __dy; return *this; }	2753	inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& __dy) noexcept { this = this - __dy; return *this; }
2717		2754
		2755
		2756	template <class _Duration>
		2757	class hh_mm_ss
		2758	{
		2759	private:
		2760	static_assert(__is_duration<_Duration>::value, "template parameter of hh_mm_ss must be a std::chrono::duration");
		2761	using __CommonType = common_type_t<_Duration, chrono::seconds>;
		2762
		2763	static constexpr uint64_t __pow10(unsigned __exp)
		2764	{
		2765	uint64_t __ret = 1;
		2766	for (unsigned __i = 0; __i < __exp; ++__i)
		2767	__ret *= 10U;
		2768	return __ret;
		2769	}
		2770
		2771	static constexpr unsigned __width(uint64_t __n, uint64_t __d = 10, unsigned __w = 0)
		2772	{
		2773	if (__n >= 2 && __d != 0 && __w < 19)
		2774	return 1 + __width(__n, __d % __n * 10, __w+1);
		2775	return 0;
		2776	}
		2777
		2778	public:
		2779	static unsigned constexpr fractional_width = __width(__CommonType::period::den) < 19 ?
		2780	__width(__CommonType::period::den) : 6u;
		2781	using precision = duration<typename __CommonType::rep, ratio<1, __pow10(fractional_width)>>;
		2782
		2783	constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {}
		2784
		2785	constexpr explicit hh_mm_ss(_Duration __d) noexcept :
		2786	__is_neg(__d < _Duration(0)),
		2787	__h(duration_cast<chrono::hours> (abs(__d))),
		2788	__m(duration_cast<chrono::minutes>(abs(__d) - hours())),
		2789	__s(duration_cast<chrono::seconds>(abs(__d) - hours() - minutes())),
		2790	__f(duration_cast<precision> (abs(__d) - hours() - minutes() - seconds()))
		2791	{}
		2792
		2793	constexpr bool is_negative() const noexcept { return __is_neg; }
		2794	constexpr chrono::hours hours() const noexcept { return __h; }
		2795	constexpr chrono::minutes minutes() const noexcept { return __m; }
		2796	constexpr chrono::seconds seconds() const noexcept { return __s; }
		2797	constexpr precision subseconds() const noexcept { return __f; }
		2798
		2799	constexpr precision to_duration() const noexcept
		2800	{
		2801	auto __dur = __h + __m + __s + __f;
		2802	return __is_neg ? -__dur : __dur;
		2803	}
		2804
		2805	constexpr explicit operator precision() const noexcept { return to_duration(); }
		2806
		2807	private:
		2808	bool __is_neg;
		2809	chrono::hours __h;
		2810	chrono::minutes __m;
		2811	chrono::seconds __s;
		2812	precision __f;
		2813	};
		2814
		2815	constexpr bool is_am(const hours& __h) noexcept { return __h >= hours( 0) && __h < hours(12); }
		2816	constexpr bool is_pm(const hours& __h) noexcept { return __h >= hours(12) && __h < hours(24); }
		2817
		2818	constexpr hours make12(const hours& __h) noexcept
		2819	{
		2820	if (__h == hours( 0)) return hours(12);
		2821	else if (__h <= hours(12)) return __h;
		2822	else return __h - hours(12);
		2823	}
		2824
		2825	constexpr hours make24(const hours& __h, bool __is_pm) noexcept
		2826	{
		2827	if (__is_pm)
		2828	return __h == hours(12) ? __h : __h + hours(12);
		2829	else
		2830	return __h == hours(12) ? hours(0) : __h;
		2831	}
		2832
2718	#endif // _LIBCPP_STD_VER > 17	2833	#endif // _LIBCPP_STD_VER > 17
2719	} // chrono	2834	} // chrono
2720		2835
...	@@ -2825,6 +2940,7 @@ struct _FilesystemClock {	...	@@ -2825,6 +2940,7 @@ struct _FilesystemClock {
2825	typedef chrono::duration<rep, period> duration;	2940	typedef chrono::duration<rep, period> duration;
2826	typedef chrono::time_point<_FilesystemClock> time_point;	2941	typedef chrono::time_point<_FilesystemClock> time_point;
2827		2942
		2943	_LIBCPP_EXPORTED_FROM_ABI
2828	static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;	2944	static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
2829		2945
2830	_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept;	2946	_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept;

lib/libcxx/include/cmath+36

...	@@ -303,11 +303,15 @@ long double truncl(long double x);	...	@@ -303,11 +303,15 @@ long double truncl(long double x);
303	#include <__config>	303	#include <__config>
304	#include <math.h>	304	#include <math.h>
305	#include <version>	305	#include <version>
		306	#include <type_traits>
306		307
307	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	308	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
308	#pragma GCC system_header	309	#pragma GCC system_header
309	#endif	310	#endif
310		311
		312	_LIBCPP_PUSH_MACROS
		313	#include <__undef_macros>
		314
311	_LIBCPP_BEGIN_NAMESPACE_STD	315	_LIBCPP_BEGIN_NAMESPACE_STD
312		316
313	using ::signbit;	317	using ::signbit;
...	@@ -632,6 +636,38 @@ lerp(long double __a, long double __b, long double __t) _NOEXCEPT { return __ler	...	@@ -632,6 +636,38 @@ lerp(long double __a, long double __b, long double __t) _NOEXCEPT { return __ler
632		636
633	#endif // _LIBCPP_STD_VER > 17	637	#endif // _LIBCPP_STD_VER > 17
634		638
		639	template <class _IntT, class _FloatT,
		640	bool _FloatBigger = (numeric_limits<_FloatT>::digits > numeric_limits<_IntT>::digits),
		641	int _Bits = (numeric_limits<_IntT>::digits - numeric_limits<_FloatT>::digits)>
		642	_LIBCPP_INLINE_VISIBILITY
		643	_LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT {
		644	static_assert(is_floating_point<_FloatT>::value, "must be a floating point type");
		645	static_assert(is_integral<_IntT>::value, "must be an integral type");
		646	static_assert(numeric_limits<_FloatT>::radix == 2, "FloatT has incorrect radix");
		647	static_assert((_IsSame<_FloatT, float>::value \|\| _IsSame<_FloatT, double>::value
		648	\|\| _IsSame<_FloatT,long double>::value), "unsupported floating point type");
		649	return _FloatBigger ? numeric_limits<_IntT>::max() : (numeric_limits<_IntT>::max() >> _Bits << _Bits);
		650	}
		651
		652	// Convert a floating point number to the specified integral type after
		653	// clamping to the integral types representable range.
		654	//
		655	// The behavior is undefined if `__r` is NaN.
		656	template <class _IntT, class _RealT>
		657	_LIBCPP_INLINE_VISIBILITY
		658	_IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
		659	using _Lim = std::numeric_limits<_IntT>;
		660	const _IntT _MaxVal = std::__max_representable_int_for_float<_IntT, _RealT>();
		661	if (__r >= ::nextafter(static_cast<_RealT>(_MaxVal), INFINITY)) {
		662	return _Lim::max();
		663	} else if (__r <= _Lim::lowest()) {
		664	return _Lim::min();
		665	}
		666	return static_cast<_IntT>(__r);
		667	}
		668
635	_LIBCPP_END_NAMESPACE_STD	669	_LIBCPP_END_NAMESPACE_STD
636		670
		671	_LIBCPP_POP_MACROS
		672
637	#endif // _LIBCPP_CMATH	673	#endif // _LIBCPP_CMATH

lib/libcxx/include/cstdio+1-1

...	@@ -152,7 +152,7 @@ using ::tmpnam;	...	@@ -152,7 +152,7 @@ using ::tmpnam;
152		152
153	#ifndef _LIBCPP_HAS_NO_STDIN	153	#ifndef _LIBCPP_HAS_NO_STDIN
154	using ::getchar;	154	using ::getchar;
155	#if _LIBCPP_STD_VER <= 11 && !defined(_LIBCPP_MSVCRT)	155	#if _LIBCPP_STD_VER <= 11 && !defined(_LIBCPP_C_HAS_NO_GETS)
156	using ::gets;	156	using ::gets;
157	#endif	157	#endif
158	using ::scanf;	158	using ::scanf;

lib/libcxx/include/cstdlib+1-1

...	@@ -154,7 +154,7 @@ using ::wcstombs;	...	@@ -154,7 +154,7 @@ using ::wcstombs;
154	using ::at_quick_exit;	154	using ::at_quick_exit;
155	using ::quick_exit;	155	using ::quick_exit;
156	#endif	156	#endif
157	#if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_C11_FEATURES)	157	#if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_ALIGNED_ALLOC)
158	using ::aligned_alloc;	158	using ::aligned_alloc;
159	#endif	159	#endif
160		160

lib/libcxx/include/ctime+3-3

...	@@ -18,7 +18,7 @@ Macros:	...	@@ -18,7 +18,7 @@ Macros:
18	NULL	18	NULL
19	CLOCKS_PER_SEC	19	CLOCKS_PER_SEC
20	TIME_UTC // C++17	20	TIME_UTC // C++17
21		21
22	namespace std	22	namespace std
23	{	23	{
24		24
...	@@ -29,7 +29,7 @@ Types:	...	@@ -29,7 +29,7 @@ Types:
29	time_t	29	time_t
30	tm	30	tm
31	timespec // C++17	31	timespec // C++17
32		32
33	clock_t clock();	33	clock_t clock();
34	double difftime(time_t time1, time_t time0);	34	double difftime(time_t time1, time_t time0);
35	time_t mktime(tm* timeptr);	35	time_t mktime(tm* timeptr);
...	@@ -58,7 +58,7 @@ using ::clock_t;	...	@@ -58,7 +58,7 @@ using ::clock_t;
58	using ::size_t;	58	using ::size_t;
59	using ::time_t;	59	using ::time_t;
60	using ::tm;	60	using ::tm;
61	#if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_C11_FEATURES)	61	#if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_TIMESPEC_GET)
62	using ::timespec;	62	using ::timespec;
63	#endif	63	#endif
64	using ::clock;	64	using ::clock;

lib/libcxx/include/deque+182-95

...	@@ -190,7 +190,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -190,7 +190,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
190	copy(_RAIter __f,	190	copy(_RAIter __f,
191	_RAIter __l,	191	_RAIter __l,
192	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	192	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
193	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);	193	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
194		194
195	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	195	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
196	class _OutputIterator>	196	class _OutputIterator>
...	@@ -212,7 +212,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -212,7 +212,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
212	copy_backward(_RAIter __f,	212	copy_backward(_RAIter __f,
213	_RAIter __l,	213	_RAIter __l,
214	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	214	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
215	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);	215	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
216		216
217	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	217	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
218	class _OutputIterator>	218	class _OutputIterator>
...	@@ -234,7 +234,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -234,7 +234,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
234	move(_RAIter __f,	234	move(_RAIter __f,
235	_RAIter __l,	235	_RAIter __l,
236	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	236	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
237	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);	237	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
238		238
239	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	239	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
240	class _OutputIterator>	240	class _OutputIterator>
...	@@ -256,7 +256,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -256,7 +256,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
256	move_backward(_RAIter __f,	256	move_backward(_RAIter __f,
257	_RAIter __l,	257	_RAIter __l,
258	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	258	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
259	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);	259	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
260		260
261	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	261	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
262	class _OutputIterator>	262	class _OutputIterator>
...	@@ -450,7 +450,7 @@ private:	...	@@ -450,7 +450,7 @@ private:
450	copy(_RAIter __f,	450	copy(_RAIter __f,
451	_RAIter __l,	451	_RAIter __l,
452	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	452	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
453	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);	453	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
454		454
455	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	455	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
456	class _OutputIterator>	456	class _OutputIterator>
...	@@ -475,7 +475,7 @@ private:	...	@@ -475,7 +475,7 @@ private:
475	copy_backward(_RAIter __f,	475	copy_backward(_RAIter __f,
476	_RAIter __l,	476	_RAIter __l,
477	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	477	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
478	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);	478	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
479		479
480	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	480	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
481	class _OutputIterator>	481	class _OutputIterator>
...	@@ -500,7 +500,7 @@ private:	...	@@ -500,7 +500,7 @@ private:
500	move(_RAIter __f,	500	move(_RAIter __f,
501	_RAIter __l,	501	_RAIter __l,
502	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	502	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
503	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);	503	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
504		504
505	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	505	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
506	class _OutputIterator>	506	class _OutputIterator>
...	@@ -525,7 +525,7 @@ private:	...	@@ -525,7 +525,7 @@ private:
525	move_backward(_RAIter __f,	525	move_backward(_RAIter __f,
526	_RAIter __l,	526	_RAIter __l,
527	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	527	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
528	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);	528	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
529		529
530	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,	530	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
531	class _OutputIterator>	531	class _OutputIterator>
...	@@ -558,7 +558,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -558,7 +558,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
558	copy(_RAIter __f,	558	copy(_RAIter __f,
559	_RAIter __l,	559	_RAIter __l,
560	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	560	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
561	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)	561	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
562	{	562	{
563	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;	563	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
564	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;	564	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
...	@@ -646,7 +646,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -646,7 +646,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
646	copy_backward(_RAIter __f,	646	copy_backward(_RAIter __f,
647	_RAIter __l,	647	_RAIter __l,
648	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	648	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
649	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)	649	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
650	{	650	{
651	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;	651	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
652	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;	652	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
...	@@ -734,7 +734,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -734,7 +734,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
734	move(_RAIter __f,	734	move(_RAIter __f,
735	_RAIter __l,	735	_RAIter __l,
736	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	736	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
737	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)	737	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
738	{	738	{
739	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;	739	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
740	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;	740	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
...	@@ -822,7 +822,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>	...	@@ -822,7 +822,7 @@ __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
822	move_backward(_RAIter __f,	822	move_backward(_RAIter __f,
823	_RAIter __l,	823	_RAIter __l,
824	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,	824	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
825	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)	825	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
826	{	826	{
827	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;	827	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
828	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;	828	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
...	@@ -934,7 +934,7 @@ public:	...	@@ -934,7 +934,7 @@ public:
934	typedef _Allocator allocator_type;	934	typedef _Allocator allocator_type;
935	typedef allocator_traits<allocator_type> __alloc_traits;	935	typedef allocator_traits<allocator_type> __alloc_traits;
936	typedef typename __alloc_traits::size_type size_type;	936	typedef typename __alloc_traits::size_type size_type;
937	protected:	937
938	typedef _Tp value_type;	938	typedef _Tp value_type;
939	typedef value_type& reference;	939	typedef value_type& reference;
940	typedef const value_type& const_reference;	940	typedef const value_type& const_reference;
...	@@ -956,6 +956,74 @@ protected:	...	@@ -956,6 +956,74 @@ protected:
956	typedef __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer,	956	typedef __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer,
957	difference_type> const_iterator;	957	difference_type> const_iterator;
958		958
		959	struct __deque_block_range {
		960	explicit __deque_block_range(pointer __b, pointer __e) _NOEXCEPT : __begin_(__b), __end_(__e) {}
		961	const pointer __begin_;
		962	const pointer __end_;
		963	};
		964
		965	struct __deque_range {
		966	iterator __pos_;
		967	const iterator __end_;
		968
		969	__deque_range(iterator __pos, iterator __e) _NOEXCEPT
		970	: __pos_(__pos), __end_(__e) {}
		971
		972	explicit operator bool() const _NOEXCEPT {
		973	return __pos_ != __end_;
		974	}
		975
		976	__deque_range begin() const {
		977	return *this;
		978	}
		979
		980	__deque_range end() const {
		981	return __deque_range(__end_, __end_);
		982	}
		983	__deque_block_range operator*() const _NOEXCEPT {
		984	if (__pos_.__m_iter_ == __end_.__m_iter_) {
		985	return __deque_block_range(__pos_.__ptr_, __end_.__ptr_);
		986	}
		987	return __deque_block_range(__pos_.__ptr_, *__pos_.__m_iter_ + __block_size);
		988	}
		989
		990	__deque_range& operator++() _NOEXCEPT {
		991	if (__pos_.__m_iter_ == __end_.__m_iter_) {
		992	__pos_ = __end_;
		993	} else {
		994	++__pos_.__m_iter_;
		995	__pos_.__ptr_ = *__pos_.__m_iter_;
		996	}
		997	return *this;
		998	}
		999
		1000
		1001	friend bool operator==(__deque_range const& __lhs, __deque_range const& __rhs) {
		1002	return __lhs.__pos_ == __rhs.__pos_;
		1003	}
		1004	friend bool operator!=(__deque_range const& __lhs, __deque_range const& __rhs) {
		1005	return !(__lhs == __rhs);
		1006	}
		1007	};
		1008
		1009
		1010
		1011	struct _ConstructTransaction {
		1012	_ConstructTransaction(__deque_base* __db, __deque_block_range& __r)
		1013	: __pos_(__r.__begin_), __end_(__r.__end_), __begin_(__r.__begin_), __base_(__db) {}
		1014
		1015
		1016	~_ConstructTransaction() {
		1017	__base_->size() += (__pos_ - __begin_);
		1018	}
		1019
		1020	pointer __pos_;
		1021	const pointer __end_;
		1022	private:
		1023	const pointer __begin_;
		1024	__deque_base * const __base_;
		1025	};
		1026
959	protected:	1027	protected:
960	__map __map_;	1028	__map __map_;
961	size_type __start_;	1029	size_type __start_;
...	@@ -1103,7 +1171,7 @@ template <class _Tp, class _Allocator>	...	@@ -1103,7 +1171,7 @@ template <class _Tp, class _Allocator>
1103	inline	1171	inline
1104	__deque_base<_Tp, _Allocator>::__deque_base()	1172	__deque_base<_Tp, _Allocator>::__deque_base()
1105	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)	1173	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
1106	: __start_(0), __size_(0) {}	1174	: __start_(0), __size_(0, __default_init_tag()) {}
1107		1175
1108	template <class _Tp, class _Allocator>	1176	template <class _Tp, class _Allocator>
1109	inline	1177	inline
...	@@ -1222,6 +1290,10 @@ public:	...	@@ -1222,6 +1290,10 @@ public:
1222	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;	1290	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
1223	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;	1291	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
1224		1292
		1293	using typename __base::__deque_range;
		1294	using typename __base::__deque_block_range;
		1295	using typename __base::_ConstructTransaction;
		1296
1225	// construct/copy/destroy:	1297	// construct/copy/destroy:
1226	_LIBCPP_INLINE_VISIBILITY	1298	_LIBCPP_INLINE_VISIBILITY
1227	deque()	1299	deque()
...	@@ -1236,10 +1308,10 @@ public:	...	@@ -1236,10 +1308,10 @@ public:
1236	deque(size_type __n, const value_type& __v, const allocator_type& __a);	1308	deque(size_type __n, const value_type& __v, const allocator_type& __a);
1237	template <class _InputIter>	1309	template <class _InputIter>
1238	deque(_InputIter __f, _InputIter __l,	1310	deque(_InputIter __f, _InputIter __l,
1239	typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0);	1311	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
1240	template <class _InputIter>	1312	template <class _InputIter>
1241	deque(_InputIter __f, _InputIter __l, const allocator_type& __a,	1313	deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
1242	typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0);	1314	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
1243	deque(const deque& __c);	1315	deque(const deque& __c);
1244	deque(const deque& __c, const allocator_type& __a);	1316	deque(const deque& __c, const allocator_type& __a);
1245		1317
...	@@ -1267,11 +1339,11 @@ public:	...	@@ -1267,11 +1339,11 @@ public:
1267		1339
1268	template <class _InputIter>	1340	template <class _InputIter>
1269	void assign(_InputIter __f, _InputIter __l,	1341	void assign(_InputIter __f, _InputIter __l,
1270	typename enable_if<__is_input_iterator<_InputIter>::value &&	1342	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
1271	!__is_random_access_iterator<_InputIter>::value>::type* = 0);	1343	!__is_cpp17_random_access_iterator<_InputIter>::value>::type* = 0);
1272	template <class _RAIter>	1344	template <class _RAIter>
1273	void assign(_RAIter __f, _RAIter __l,	1345	void assign(_RAIter __f, _RAIter __l,
1274	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);	1346	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
1275	void assign(size_type __n, const value_type& __v);	1347	void assign(size_type __n, const value_type& __v);
1276		1348
1277	_LIBCPP_INLINE_VISIBILITY	1349	_LIBCPP_INLINE_VISIBILITY
...	@@ -1371,15 +1443,15 @@ public:	...	@@ -1371,15 +1443,15 @@ public:
1371	iterator insert(const_iterator __p, size_type __n, const value_type& __v);	1443	iterator insert(const_iterator __p, size_type __n, const value_type& __v);
1372	template <class _InputIter>	1444	template <class _InputIter>
1373	iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,	1445	iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,
1374	typename enable_if<__is_input_iterator<_InputIter>::value	1446	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value
1375	&&!__is_forward_iterator<_InputIter>::value>::type* = 0);	1447	&&!__is_cpp17_forward_iterator<_InputIter>::value>::type* = 0);
1376	template <class _ForwardIterator>	1448	template <class _ForwardIterator>
1377	iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,	1449	iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
1378	typename enable_if<__is_forward_iterator<_ForwardIterator>::value	1450	typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value
1379	&&!__is_bidirectional_iterator<_ForwardIterator>::value>::type* = 0);	1451	&&!__is_cpp17_bidirectional_iterator<_ForwardIterator>::value>::type* = 0);
1380	template <class _BiIter>	1452	template <class _BiIter>
1381	iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,	1453	iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,
1382	typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type* = 0);	1454	typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type* = 0);
1383		1455
1384	void pop_front();	1456	void pop_front();
1385	void pop_back();	1457	void pop_back();
...	@@ -1399,7 +1471,7 @@ public:	...	@@ -1399,7 +1471,7 @@ public:
1399		1471
1400	_LIBCPP_INLINE_VISIBILITY	1472	_LIBCPP_INLINE_VISIBILITY
1401	bool __invariants() const {return __base::__invariants();}	1473	bool __invariants() const {return __base::__invariants();}
1402	private:	1474
1403	typedef typename __base::__map_const_pointer __map_const_pointer;	1475	typedef typename __base::__map_const_pointer __map_const_pointer;
1404		1476
1405	_LIBCPP_INLINE_VISIBILITY	1477	_LIBCPP_INLINE_VISIBILITY
...	@@ -1412,24 +1484,62 @@ private:	...	@@ -1412,24 +1484,62 @@ private:
1412	{	1484	{
1413	return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;	1485	return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;
1414	}	1486	}
		1487	_LIBCPP_INLINE_VISIBILITY
		1488	size_type __block_count() const
		1489	{
		1490	return __base::__map_.size();
		1491	}
		1492
1415	_LIBCPP_INLINE_VISIBILITY	1493	_LIBCPP_INLINE_VISIBILITY
1416	size_type __front_spare() const	1494	size_type __front_spare() const
1417	{	1495	{
1418	return __base::__start_;	1496	return __base::__start_;
1419	}	1497	}
1420	_LIBCPP_INLINE_VISIBILITY	1498	_LIBCPP_INLINE_VISIBILITY
		1499	size_type __front_spare_blocks() const {
		1500	return __front_spare() / __base::__block_size;
		1501	}
		1502	_LIBCPP_INLINE_VISIBILITY
1421	size_type __back_spare() const	1503	size_type __back_spare() const
1422	{	1504	{
1423	return __capacity() - (__base::__start_ + __base::size());	1505	return __capacity() - (__base::__start_ + __base::size());
1424	}	1506	}
		1507	_LIBCPP_INLINE_VISIBILITY
		1508	size_type __back_spare_blocks() const {
		1509	return __back_spare() / __base::__block_size;
		1510	}
		1511
		1512	private:
		1513	_LIBCPP_INLINE_VISIBILITY
		1514	bool __maybe_remove_front_spare(bool __keep_one = true) {
		1515	if (__front_spare_blocks() >= 2 \|\| (!__keep_one && __front_spare_blocks())) {
		1516	__alloc_traits::deallocate(__base::__alloc(), __base::__map_.front(),
		1517	__base::__block_size);
		1518	__base::__map_.pop_front();
		1519	__base::__start_ -= __base::__block_size;
		1520	return true;
		1521	}
		1522	return false;
		1523	}
		1524
		1525	_LIBCPP_INLINE_VISIBILITY
		1526	bool __maybe_remove_back_spare(bool __keep_one = true) {
		1527	if (__back_spare_blocks() >= 2 \|\| (!__keep_one && __back_spare_blocks())) {
		1528	__alloc_traits::deallocate(__base::__alloc(), __base::__map_.back(),
		1529	__base::__block_size);
		1530	__base::__map_.pop_back();
		1531	return true;
		1532	}
		1533	return false;
		1534	}
1425		1535
1426	template <class _InpIter>	1536	template <class _InpIter>
1427	void __append(_InpIter __f, _InpIter __l,	1537	void __append(_InpIter __f, _InpIter __l,
1428	typename enable_if<__is_input_iterator<_InpIter>::value &&	1538	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value &&
1429	!__is_forward_iterator<_InpIter>::value>::type* = 0);	1539	!__is_cpp17_forward_iterator<_InpIter>::value>::type* = 0);
1430	template <class _ForIter>	1540	template <class _ForIter>
1431	void __append(_ForIter __f, _ForIter __l,	1541	void __append(_ForIter __f, _ForIter __l,
1432	typename enable_if<__is_forward_iterator<_ForIter>::value>::type* = 0);	1542	typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type* = 0);
1433	void __append(size_type __n);	1543	void __append(size_type __n);
1434	void __append(size_type __n, const value_type& __v);	1544	void __append(size_type __n, const value_type& __v);
1435	void __erase_to_end(const_iterator __f);	1545	void __erase_to_end(const_iterator __f);
...	@@ -1524,7 +1634,7 @@ deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v, const alloca	...	@@ -1524,7 +1634,7 @@ deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v, const alloca
1524	template <class _Tp, class _Allocator>	1634	template <class _Tp, class _Allocator>
1525	template <class _InputIter>	1635	template <class _InputIter>
1526	deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,	1636	deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,
1527	typename enable_if<__is_input_iterator<_InputIter>::value>::type*)	1637	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type*)
1528	{	1638	{
1529	__append(__f, __l);	1639	__append(__f, __l);
1530	}	1640	}
...	@@ -1532,7 +1642,7 @@ deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,	...	@@ -1532,7 +1642,7 @@ deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,
1532	template <class _Tp, class _Allocator>	1642	template <class _Tp, class _Allocator>
1533	template <class _InputIter>	1643	template <class _InputIter>
1534	deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a,	1644	deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
1535	typename enable_if<__is_input_iterator<_InputIter>::value>::type*)	1645	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type*)
1536	: __base(__a)	1646	: __base(__a)
1537	{	1647	{
1538	__append(__f, __l);	1648	__append(__f, __l);
...	@@ -1640,8 +1750,8 @@ template <class _Tp, class _Allocator>	...	@@ -1640,8 +1750,8 @@ template <class _Tp, class _Allocator>
1640	template <class _InputIter>	1750	template <class _InputIter>
1641	void	1751	void
1642	deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,	1752	deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,
1643	typename enable_if<__is_input_iterator<_InputIter>::value &&	1753	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
1644	!__is_random_access_iterator<_InputIter>::value>::type*)	1754	!__is_cpp17_random_access_iterator<_InputIter>::value>::type*)
1645	{	1755	{
1646	iterator __i = __base::begin();	1756	iterator __i = __base::begin();
1647	iterator __e = __base::end();	1757	iterator __e = __base::end();
...	@@ -1657,7 +1767,7 @@ template <class _Tp, class _Allocator>	...	@@ -1657,7 +1767,7 @@ template <class _Tp, class _Allocator>
1657	template <class _RAIter>	1767	template <class _RAIter>
1658	void	1768	void
1659	deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,	1769	deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
1660	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)	1770	typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
1661	{	1771	{
1662	if (static_cast<size_type>(__l - __f) > __base::size())	1772	if (static_cast<size_type>(__l - __f) > __base::size())
1663	{	1773	{
...	@@ -1727,17 +1837,8 @@ deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT	...	@@ -1727,17 +1837,8 @@ deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
1727	}	1837	}
1728	else	1838	else
1729	{	1839	{
1730	if (__front_spare() >= __base::__block_size)	1840	__maybe_remove_front_spare(/__keep_one=/false);
1731	{	1841	__maybe_remove_back_spare(/__keep_one=/false);
1732	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
1733	__base::__map_.pop_front();
1734	__base::__start_ -= __base::__block_size;
1735	}
1736	if (__back_spare() >= __base::__block_size)
1737	{
1738	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
1739	__base::__map_.pop_back();
1740	}
1741	}	1842	}
1742	__base::__map_.shrink_to_fit();	1843	__base::__map_.shrink_to_fit();
1743	}	1844	}
...	@@ -2151,8 +2252,8 @@ template <class _Tp, class _Allocator>	...	@@ -2151,8 +2252,8 @@ template <class _Tp, class _Allocator>
2151	template <class _InputIter>	2252	template <class _InputIter>
2152	typename deque<_Tp, _Allocator>::iterator	2253	typename deque<_Tp, _Allocator>::iterator
2153	deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l,	2254	deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l,
2154	typename enable_if<__is_input_iterator<_InputIter>::value	2255	typename enable_if<__is_cpp17_input_iterator<_InputIter>::value
2155	&&!__is_forward_iterator<_InputIter>::value>::type*)	2256	&&!__is_cpp17_forward_iterator<_InputIter>::value>::type*)
2156	{	2257	{
2157	__split_buffer<value_type, allocator_type&> __buf(__base::__alloc());	2258	__split_buffer<value_type, allocator_type&> __buf(__base::__alloc());
2158	__buf.__construct_at_end(__f, __l);	2259	__buf.__construct_at_end(__f, __l);
...	@@ -2164,8 +2265,8 @@ template <class _Tp, class _Allocator>	...	@@ -2164,8 +2265,8 @@ template <class _Tp, class _Allocator>
2164	template <class _ForwardIterator>	2265	template <class _ForwardIterator>
2165	typename deque<_Tp, _Allocator>::iterator	2266	typename deque<_Tp, _Allocator>::iterator
2166	deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,	2267	deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
2167	typename enable_if<__is_forward_iterator<_ForwardIterator>::value	2268	typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value
2168	&&!__is_bidirectional_iterator<_ForwardIterator>::value>::type*)	2269	&&!__is_cpp17_bidirectional_iterator<_ForwardIterator>::value>::type*)
2169	{	2270	{
2170	size_type __n = _VSTD::distance(__f, __l);	2271	size_type __n = _VSTD::distance(__f, __l);
2171	__split_buffer<value_type, allocator_type&> __buf(__n, 0, __base::__alloc());	2272	__split_buffer<value_type, allocator_type&> __buf(__n, 0, __base::__alloc());
...	@@ -2178,7 +2279,7 @@ template <class _Tp, class _Allocator>	...	@@ -2178,7 +2279,7 @@ template <class _Tp, class _Allocator>
2178	template <class _BiIter>	2279	template <class _BiIter>
2179	typename deque<_Tp, _Allocator>::iterator	2280	typename deque<_Tp, _Allocator>::iterator
2180	deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,	2281	deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
2181	typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type*)	2282	typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type*)
2182	{	2283	{
2183	size_type __n = _VSTD::distance(__f, __l);	2284	size_type __n = _VSTD::distance(__f, __l);
2184	size_type __pos = __p - __base::begin();	2285	size_type __pos = __p - __base::begin();
...	@@ -2247,8 +2348,8 @@ template <class _Tp, class _Allocator>	...	@@ -2247,8 +2348,8 @@ template <class _Tp, class _Allocator>
2247	template <class _InpIter>	2348	template <class _InpIter>
2248	void	2349	void
2249	deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,	2350	deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
2250	typename enable_if<__is_input_iterator<_InpIter>::value &&	2351	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value &&
2251	!__is_forward_iterator<_InpIter>::value>::type*)	2352	!__is_cpp17_forward_iterator<_InpIter>::value>::type*)
2252	{	2353	{
2253	for (; __f != __l; ++__f)	2354	for (; __f != __l; ++__f)
2254	#ifdef _LIBCPP_CXX03_LANG	2355	#ifdef _LIBCPP_CXX03_LANG
...	@@ -2262,7 +2363,7 @@ template <class _Tp, class _Allocator>	...	@@ -2262,7 +2363,7 @@ template <class _Tp, class _Allocator>
2262	template <class _ForIter>	2363	template <class _ForIter>
2263	void	2364	void
2264	deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,	2365	deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
2265	typename enable_if<__is_forward_iterator<_ForIter>::value>::type*)	2366	typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type*)
2266	{	2367	{
2267	size_type __n = _VSTD::distance(__f, __l);	2368	size_type __n = _VSTD::distance(__f, __l);
2268	allocator_type& __a = __base::__alloc();	2369	allocator_type& __a = __base::__alloc();
...	@@ -2270,8 +2371,12 @@ deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,	...	@@ -2270,8 +2371,12 @@ deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
2270	if (__n > __back_capacity)	2371	if (__n > __back_capacity)
2271	__add_back_capacity(__n - __back_capacity);	2372	__add_back_capacity(__n - __back_capacity);
2272	// __n <= __back_capacity	2373	// __n <= __back_capacity
2273	for (iterator __i = __base::end(); __f != __l; ++__i, (void) ++__f, ++__base::size())	2374	for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
2274	__alloc_traits::construct(__a, _VSTD::addressof(__i), __f);	2375	_ConstructTransaction __tx(this, __br);
		2376	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {
		2377	__alloc_traits::construct(__a, std::__to_address(__tx.__pos_), *__f);
		2378	}
		2379	}
2275	}	2380	}
2276		2381
2277	template <class _Tp, class _Allocator>	2382	template <class _Tp, class _Allocator>
...	@@ -2283,8 +2388,12 @@ deque<_Tp, _Allocator>::__append(size_type __n)	...	@@ -2283,8 +2388,12 @@ deque<_Tp, _Allocator>::__append(size_type __n)
2283	if (__n > __back_capacity)	2388	if (__n > __back_capacity)
2284	__add_back_capacity(__n - __back_capacity);	2389	__add_back_capacity(__n - __back_capacity);
2285	// __n <= __back_capacity	2390	// __n <= __back_capacity
2286	for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())	2391	for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
2287	__alloc_traits::construct(__a, _VSTD::addressof(*__i));	2392	_ConstructTransaction __tx(this, __br);
		2393	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
		2394	__alloc_traits::construct(__a, std::__to_address(__tx.__pos_));
		2395	}
		2396	}
2288	}	2397	}
2289		2398
2290	template <class _Tp, class _Allocator>	2399	template <class _Tp, class _Allocator>
...	@@ -2296,8 +2405,13 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)	...	@@ -2296,8 +2405,13 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
2296	if (__n > __back_capacity)	2405	if (__n > __back_capacity)
2297	__add_back_capacity(__n - __back_capacity);	2406	__add_back_capacity(__n - __back_capacity);
2298	// __n <= __back_capacity	2407	// __n <= __back_capacity
2299	for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())	2408	for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
2300	__alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);	2409	_ConstructTransaction __tx(this, __br);
		2410	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
		2411	__alloc_traits::construct(__a, std::__to_address(__tx.__pos_), __v);
		2412	}
		2413	}
		2414
2301	}	2415	}
2302		2416
2303	// Create front capacity for one block of elements.	2417	// Create front capacity for one block of elements.
...	@@ -2592,16 +2706,12 @@ void	...	@@ -2592,16 +2706,12 @@ void
2592	deque<_Tp, _Allocator>::pop_front()	2706	deque<_Tp, _Allocator>::pop_front()
2593	{	2707	{
2594	allocator_type& __a = __base::__alloc();	2708	allocator_type& __a = __base::__alloc();
2595	__alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +	2709	__alloc_traits::destroy(__a, __to_address(*(__base::__map_.begin() +
2596	__base::__start_ / __base::__block_size) +	2710	__base::__start_ / __base::__block_size) +
2597	__base::__start_ % __base::__block_size));	2711	__base::__start_ % __base::__block_size));
2598	--__base::size();	2712	--__base::size();
2599	if (++__base::__start_ >= 2 * __base::__block_size)	2713	++__base::__start_;
2600	{	2714	__maybe_remove_front_spare();
2601	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
2602	__base::__map_.pop_front();
2603	__base::__start_ -= __base::__block_size;
2604	}
2605	}	2715	}
2606		2716
2607	template <class _Tp, class _Allocator>	2717	template <class _Tp, class _Allocator>
...	@@ -2611,15 +2721,11 @@ deque<_Tp, _Allocator>::pop_back()	...	@@ -2611,15 +2721,11 @@ deque<_Tp, _Allocator>::pop_back()
2611	_LIBCPP_ASSERT(!empty(), "deque::pop_back called for empty deque");	2721	_LIBCPP_ASSERT(!empty(), "deque::pop_back called for empty deque");
2612	allocator_type& __a = __base::__alloc();	2722	allocator_type& __a = __base::__alloc();
2613	size_type __p = __base::size() + __base::__start_ - 1;	2723	size_type __p = __base::size() + __base::__start_ - 1;
2614	__alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +	2724	__alloc_traits::destroy(__a, __to_address(*(__base::__map_.begin() +
2615	__p / __base::__block_size) +	2725	__p / __base::__block_size) +
2616	__p % __base::__block_size));	2726	__p % __base::__block_size));
2617	--__base::size();	2727	--__base::size();
2618	if (__back_spare() >= 2 * __base::__block_size)	2728	__maybe_remove_back_spare();
2619	{
2620	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2621	__base::__map_.pop_back();
2622	}
2623	}	2729	}
2624		2730
2625	// move assign [__f, __l) to [__r, __r + (__l-__f)).	2731	// move assign [__f, __l) to [__r, __r + (__l-__f)).
...	@@ -2768,23 +2874,14 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)	...	@@ -2768,23 +2874,14 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
2768	__alloc_traits::destroy(__a, _VSTD::addressof(*__b));	2874	__alloc_traits::destroy(__a, _VSTD::addressof(*__b));
2769	--__base::size();	2875	--__base::size();
2770	++__base::__start_;	2876	++__base::__start_;
2771	if (__front_spare() >= 2 * __base::__block_size)	2877	__maybe_remove_front_spare();
2772	{
2773	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
2774	__base::__map_.pop_front();
2775	__base::__start_ -= __base::__block_size;
2776	}
2777	}	2878	}
2778	else	2879	else
2779	{ // erase from back	2880	{ // erase from back
2780	iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);	2881	iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
2781	__alloc_traits::destroy(__a, _VSTD::addressof(*__i));	2882	__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
2782	--__base::size();	2883	--__base::size();
2783	if (__back_spare() >= 2 * __base::__block_size)	2884	__maybe_remove_back_spare();
2784	{
2785	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2786	__base::__map_.pop_back();
2787	}
2788	}	2885	}
2789	return __base::begin() + __pos;	2886	return __base::begin() + __pos;
2790	}	2887	}
...	@@ -2807,11 +2904,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)	...	@@ -2807,11 +2904,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
2807	__alloc_traits::destroy(__a, _VSTD::addressof(*__b));	2904	__alloc_traits::destroy(__a, _VSTD::addressof(*__b));
2808	__base::size() -= __n;	2905	__base::size() -= __n;
2809	__base::__start_ += __n;	2906	__base::__start_ += __n;
2810	while (__front_spare() >= 2 * __base::__block_size)	2907	while (__maybe_remove_front_spare()) {
2811	{
2812	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
2813	__base::__map_.pop_front();
2814	__base::__start_ -= __base::__block_size;
2815	}	2908	}
2816	}	2909	}
2817	else	2910	else
...	@@ -2820,10 +2913,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)	...	@@ -2820,10 +2913,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
2820	for (iterator __e = __base::end(); __i != __e; ++__i)	2913	for (iterator __e = __base::end(); __i != __e; ++__i)
2821	__alloc_traits::destroy(__a, _VSTD::addressof(*__i));	2914	__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
2822	__base::size() -= __n;	2915	__base::size() -= __n;
2823	while (__back_spare() >= 2 * __base::__block_size)	2916	while (__maybe_remove_back_spare()) {
2824	{
2825	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2826	__base::__map_.pop_back();
2827	}	2917	}
2828	}	2918	}
2829	}	2919	}
...	@@ -2844,10 +2934,7 @@ deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)	...	@@ -2844,10 +2934,7 @@ deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
2844	for (iterator __p = __b + __pos; __p != __e; ++__p)	2934	for (iterator __p = __b + __pos; __p != __e; ++__p)
2845	__alloc_traits::destroy(__a, _VSTD::addressof(*__p));	2935	__alloc_traits::destroy(__a, _VSTD::addressof(*__p));
2846	__base::size() -= __n;	2936	__base::size() -= __n;
2847	while (__back_spare() >= 2 * __base::__block_size)	2937	while (__maybe_remove_back_spare()) {
2848	{
2849	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2850	__base::__map_.pop_back();
2851	}	2938	}
2852	}	2939	}
2853	}	2940	}

lib/libcxx/include/execution created+19

...	@@ -0,0 +1,19 @@
1	// -- C++ --
2	//===------------------------- execution ---------------------------------===//
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_EXECUTION
11	#define _LIBCPP_EXECUTION
12
13	#include <__config>
14
15	#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
16	# include <__pstl_execution>
17	#endif
18
19	#endif // _LIBCPP_EXECUTION

lib/libcxx/include/experimental/coroutine-1

...	@@ -51,7 +51,6 @@ template <class P> struct hash<coroutine_handle<P>>;	...	@@ -51,7 +51,6 @@ template <class P> struct hash<coroutine_handle<P>>;
51	#include <functional>	51	#include <functional>
52	#include <memory> // for hash<T*>	52	#include <memory> // for hash<T*>
53	#include <cstddef>	53	#include <cstddef>
54	#include <cassert>
55	#include <__debug>	54	#include <__debug>
56		55
57	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	56	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

lib/libcxx/include/experimental/functional+39-39

lib/libcxx/include/experimental/iterator+6-6

lib/libcxx/include/experimental/propagate_const-1

...	@@ -575,4 +575,3 @@ _LIBCPP_END_NAMESPACE_STD	...	@@ -575,4 +575,3 @@ _LIBCPP_END_NAMESPACE_STD
575		575
576	#endif // _LIBCPP_STD_VER > 11	576	#endif // _LIBCPP_STD_VER > 11
577	#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST	577	#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
578

lib/libcxx/include/experimental/type_traits+3-3

lib/libcxx/include/ext/hash_map+15-13

 @@ -39,14 +39,17 @@ public:
     typedef /unspecified/ iterator;
     typedef /unspecified/ const_iterator;
-    explicit hash_map(size_type n = 193, const hasher& hf = hasher(),
+    hash_map();
+    explicit hash_map(size_type n, const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
-        hash_map(InputIterator f, InputIterator l,
+    hash_map(InputIterator f, InputIterator l);
-                      size_type n = 193, const hasher& hf = hasher(),
+    template <class InputIterator>
-                      const key_equal& eql = key_equal(),
+    hash_map(InputIterator f, InputIterator l,
-                      const allocator_type& a = allocator_type());
+                size_type n, const hasher& hf = hasher(),
+                const key_equal& eql = key_equal(),
+                const allocator_type& a = allocator_type());
     hash_map(const hash_map&);
     ~hash_map();
     hash_map& operator=(const hash_map&);
 @@ -315,12 +318,13 @@ private:
     allocator_type& __na_;
-    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&);
 public:
     bool __first_constructed;
     bool __second_constructed;
+    __hash_map_node_destructor(__hash_map_node_destructor const&) = default;
+    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&) = delete;
     _LIBCPP_INLINE_VISIBILITY
     explicit __hash_map_node_destructor(allocator_type& __na)
         : __na_(__na),
 @@ -391,10 +395,10 @@ public:
         return __t;
     }
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ == __y.__i_;}
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 @@ -502,7 +506,7 @@ public:
     typedef __hash_map_iterator<typename __table::iterator>       iterator;
     typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
-    _LIBCPP_INLINE_VISIBILITY hash_map() {__table_.rehash(193);}
+    _LIBCPP_INLINE_VISIBILITY hash_map() { }
     explicit hash_map(size_type __n, const hasher& __hf = hasher(),
                            const key_equal& __eql = key_equal());
     hash_map(size_type __n, const hasher& __hf,
 @@ -623,7 +627,6 @@ template <class _InputIterator>
 hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
         _InputIterator __first, _InputIterator __last)
 {
-    __table_.rehash(193);
     insert(__first, __last);
 }
 @@ -775,7 +778,7 @@ public:
     typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
     _LIBCPP_INLINE_VISIBILITY
-    hash_multimap() {__table_.rehash(193);}
+    hash_multimap() { }
     explicit hash_multimap(size_type __n, const hasher& __hf = hasher(),
                                 const key_equal& __eql = key_equal());
     hash_multimap(size_type __n, const hasher& __hf,
 @@ -890,7 +893,6 @@ template <class _InputIterator>
 hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
         _InputIterator __first, _InputIterator __last)
 {
-    __table_.rehash(193);
     insert(__first, __last);
 }

lib/libcxx/include/ext/hash_set+2-4

...	@@ -237,7 +237,7 @@ public:	...	@@ -237,7 +237,7 @@ public:
237	typedef typename __table::const_iterator const_iterator;	237	typedef typename __table::const_iterator const_iterator;
238		238
239	_LIBCPP_INLINE_VISIBILITY	239	_LIBCPP_INLINE_VISIBILITY
240	hash_set() {__table_.rehash(193);}	240	hash_set() { }
241	explicit hash_set(size_type __n, const hasher& __hf = hasher(),	241	explicit hash_set(size_type __n, const hasher& __hf = hasher(),
242	const key_equal& __eql = key_equal());	242	const key_equal& __eql = key_equal());
243	hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,	243	hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
...	@@ -347,7 +347,6 @@ template <class _InputIterator>	...	@@ -347,7 +347,6 @@ template <class _InputIterator>
347	hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(	347	hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
348	_InputIterator __first, _InputIterator __last)	348	_InputIterator __first, _InputIterator __last)
349	{	349	{
350	__table_.rehash(193);
351	insert(__first, __last);	350	insert(__first, __last);
352	}	351	}
353		352
...	@@ -459,7 +458,7 @@ public:	...	@@ -459,7 +458,7 @@ public:
459	typedef typename __table::const_iterator const_iterator;	458	typedef typename __table::const_iterator const_iterator;
460		459
461	_LIBCPP_INLINE_VISIBILITY	460	_LIBCPP_INLINE_VISIBILITY
462	hash_multiset() {__table_.rehash(193);}	461	hash_multiset() { }
463	explicit hash_multiset(size_type __n, const hasher& __hf = hasher(),	462	explicit hash_multiset(size_type __n, const hasher& __hf = hasher(),
464	const key_equal& __eql = key_equal());	463	const key_equal& __eql = key_equal());
465	hash_multiset(size_type __n, const hasher& __hf,	464	hash_multiset(size_type __n, const hasher& __hf,
...	@@ -569,7 +568,6 @@ template <class _InputIterator>	...	@@ -569,7 +568,6 @@ template <class _InputIterator>
569	hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(	568	hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
570	_InputIterator __first, _InputIterator __last)	569	_InputIterator __first, _InputIterator __last)
571	{	570	{
572	__table_.rehash(193);
573	insert(__first, __last);	571	insert(__first, __last);
574	}	572	}
575		573

lib/libcxx/include/filesystem+4-3

 @@ -625,7 +625,7 @@ struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
   static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
 };
-template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value,
+template <class _Iter, bool _IsIt = __is_cpp17_input_iterator<_Iter>::value,
           class = void>
 struct __is_pathable_iter : false_type {};
 @@ -708,14 +708,14 @@ template <>
 struct _PathCVT<char> {
   template <class _Iter>
-  static typename enable_if<__is_exactly_input_iterator<_Iter>::value>::type
+  static typename enable_if<__is_exactly_cpp17_input_iterator<_Iter>::value>::type
   __append_range(string& __dest, _Iter __b, _Iter __e) {
     for (; __b != __e; ++__b)
       __dest.push_back(*__b);
   }
   template <class _Iter>
-  static typename enable_if<__is_forward_iterator<_Iter>::value>::type
+  static typename enable_if<__is_cpp17_forward_iterator<_Iter>::value>::type
   __append_range(string& __dest, _Iter __b, _Iter __e) {
     __dest.__append_forward_unsafe(__b, __e);
   }
 @@ -2583,6 +2583,7 @@ public:
   void disable_recursion_pending() { __rec_ = false; }
 private:
+  _LIBCPP_FUNC_VIS
   recursive_directory_iterator(const path& __p, directory_options __opt,
                                error_code* __ec);

lib/libcxx/include/forward_list+12-12

...	@@ -490,7 +490,7 @@ protected:	...	@@ -490,7 +490,7 @@ protected:
490	_LIBCPP_INLINE_VISIBILITY	490	_LIBCPP_INLINE_VISIBILITY
491	__forward_list_base()	491	__forward_list_base()
492	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)	492	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
493	: __before_begin_(__begin_node()) {}	493	: __before_begin_(__begin_node(), __default_init_tag()) {}
494	_LIBCPP_INLINE_VISIBILITY	494	_LIBCPP_INLINE_VISIBILITY
495	explicit __forward_list_base(const allocator_type& __a)	495	explicit __forward_list_base(const allocator_type& __a)
496	: __before_begin_(__begin_node(), __node_allocator(__a)) {}	496	: __before_begin_(__begin_node(), __node_allocator(__a)) {}
...	@@ -670,13 +670,13 @@ public:	...	@@ -670,13 +670,13 @@ public:
670	template <class _InputIterator>	670	template <class _InputIterator>
671	forward_list(_InputIterator __f, _InputIterator __l,	671	forward_list(_InputIterator __f, _InputIterator __l,
672	typename enable_if<	672	typename enable_if<
673	__is_input_iterator<_InputIterator>::value	673	__is_cpp17_input_iterator<_InputIterator>::value
674	>::type* = nullptr);	674	>::type* = nullptr);
675	template <class _InputIterator>	675	template <class _InputIterator>
676	forward_list(_InputIterator __f, _InputIterator __l,	676	forward_list(_InputIterator __f, _InputIterator __l,
677	const allocator_type& __a,	677	const allocator_type& __a,
678	typename enable_if<	678	typename enable_if<
679	__is_input_iterator<_InputIterator>::value	679	__is_cpp17_input_iterator<_InputIterator>::value
680	>::type* = nullptr);	680	>::type* = nullptr);
681	forward_list(const forward_list& __x);	681	forward_list(const forward_list& __x);
682	forward_list(const forward_list& __x, const allocator_type& __a);	682	forward_list(const forward_list& __x, const allocator_type& __a);
...	@@ -711,7 +711,7 @@ public:	...	@@ -711,7 +711,7 @@ public:
711	template <class _InputIterator>	711	template <class _InputIterator>
712	typename enable_if	712	typename enable_if
713	<	713	<
714	__is_input_iterator<_InputIterator>::value,	714	__is_cpp17_input_iterator<_InputIterator>::value,
715	void	715	void
716	>::type	716	>::type
717	assign(_InputIterator __f, _InputIterator __l);	717	assign(_InputIterator __f, _InputIterator __l);
...	@@ -792,7 +792,7 @@ public:	...	@@ -792,7 +792,7 @@ public:
792	_LIBCPP_INLINE_VISIBILITY	792	_LIBCPP_INLINE_VISIBILITY
793	typename enable_if	793	typename enable_if
794	<	794	<
795	__is_input_iterator<_InputIterator>::value,	795	__is_cpp17_input_iterator<_InputIterator>::value,
796	iterator	796	iterator
797	>::type	797	>::type
798	insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);	798	insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);
...	@@ -950,7 +950,7 @@ template <class _Tp, class _Alloc>	...	@@ -950,7 +950,7 @@ template <class _Tp, class _Alloc>
950	template <class _InputIterator>	950	template <class _InputIterator>
951	forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,	951	forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,
952	typename enable_if<	952	typename enable_if<
953	__is_input_iterator<_InputIterator>::value	953	__is_cpp17_input_iterator<_InputIterator>::value
954	>::type*)	954	>::type*)
955	{	955	{
956	insert_after(cbefore_begin(), __f, __l);	956	insert_after(cbefore_begin(), __f, __l);
...	@@ -961,7 +961,7 @@ template <class _InputIterator>	...	@@ -961,7 +961,7 @@ template <class _InputIterator>
961	forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,	961	forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,
962	const allocator_type& __a,	962	const allocator_type& __a,
963	typename enable_if<	963	typename enable_if<
964	__is_input_iterator<_InputIterator>::value	964	__is_cpp17_input_iterator<_InputIterator>::value
965	>::type*)	965	>::type*)
966	: base(__a)	966	: base(__a)
967	{	967	{
...	@@ -1074,7 +1074,7 @@ template <class _Tp, class _Alloc>	...	@@ -1074,7 +1074,7 @@ template <class _Tp, class _Alloc>
1074	template <class _InputIterator>	1074	template <class _InputIterator>
1075	typename enable_if	1075	typename enable_if
1076	<	1076	<
1077	__is_input_iterator<_InputIterator>::value,	1077	__is_cpp17_input_iterator<_InputIterator>::value,
1078	void	1078	void
1079	>::type	1079	>::type
1080	forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)	1080	forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
...	@@ -1270,7 +1270,7 @@ template <class _Tp, class _Alloc>	...	@@ -1270,7 +1270,7 @@ template <class _Tp, class _Alloc>
1270	template <class _InputIterator>	1270	template <class _InputIterator>
1271	typename enable_if	1271	typename enable_if
1272	<	1272	<
1273	__is_input_iterator<_InputIterator>::value,	1273	__is_cpp17_input_iterator<_InputIterator>::value,
1274	typename forward_list<_Tp, _Alloc>::iterator	1274	typename forward_list<_Tp, _Alloc>::iterator
1275	>::type	1275	>::type
1276	forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,	1276	forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
...	@@ -1525,7 +1525,7 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)	...	@@ -1525,7 +1525,7 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)
1525	else	1525	else
1526	++__i;	1526	++__i;
1527	}	1527	}
1528		1528
1529	return (__remove_return_type) __count_removed;	1529	return (__remove_return_type) __count_removed;
1530	}	1530	}
1531		1531
...	@@ -1553,7 +1553,7 @@ forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)	...	@@ -1553,7 +1553,7 @@ forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
1553	else	1553	else
1554	++__i;	1554	++__i;
1555	}	1555	}
1556		1556
1557	return (__remove_return_type) __count_removed;	1557	return (__remove_return_type) __count_removed;
1558	}	1558	}
1559		1559
...	@@ -1573,7 +1573,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)	...	@@ -1573,7 +1573,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
1573	__deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);	1573	__deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
1574	__i = __j;	1574	__i = __j;
1575	}	1575	}
1576		1576
1577	return (__remove_return_type) __count_removed;	1577	return (__remove_return_type) __count_removed;
1578	}	1578	}
1579		1579

lib/libcxx/include/fstream+14-15

 @@ -508,34 +508,34 @@ const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(
   switch (__mode & ~ios_base::ate) {
   case ios_base::out:
   case ios_base::out | ios_base::trunc:
-    return "w";
+    return "w" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::out | ios_base::app:
   case ios_base::app:
-    return "a";
+    return "a" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in:
-    return "r";
+    return "r" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::out:
-    return "r+";
+    return "r+" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::out | ios_base::trunc:
-    return "w+";
+    return "w+" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::out | ios_base::app:
   case ios_base::in | ios_base::app:
-    return "a+";
+    return "a+" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::out | ios_base::binary:
   case ios_base::out | ios_base::trunc | ios_base::binary:
-    return "wb";
+    return "wb" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::out | ios_base::app | ios_base::binary:
   case ios_base::app | ios_base::binary:
-    return "ab";
+    return "ab" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::binary:
-    return "rb";
+    return "rb" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::out | ios_base::binary:
-    return "r+b";
+    return "r+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
-    return "w+b";
+    return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
   case ios_base::in | ios_base::app | ios_base::binary:
-    return "a+b";
+    return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
   default:
     return nullptr;
   }
 @@ -697,10 +697,9 @@ basic_filebuf<_CharT, _Traits>::close()
         unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose);
         if (sync())
             __rt = 0;
-        if (fclose(__h.release()) == 0)
+        if (fclose(__h.release()))
-            __file_ = 0;
-        else
             __rt = 0;
+        __file_ = 0;
         setbuf(0, 0);
     }
     return __rt;

lib/libcxx/include/functional+54

...	@@ -440,6 +440,13 @@ public:	...	@@ -440,6 +440,13 @@ public:
440	template <typename T> const T* target() const noexcept;	440	template <typename T> const T* target() const noexcept;
441	};	441	};
442		442
		443	// Deduction guides
		444	template<class R, class ...Args>
		445	function(R(*)(Args...)) -> function<R(Args...)>; // since C++17
		446
		447	template<class F>
		448	function(F) -> function<see-below>; // since C++17
		449
443	// Null pointer comparisons:	450	// Null pointer comparisons:
444	template <class R, class ... ArgTypes>	451	template <class R, class ... ArgTypes>
445	bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;	452	bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
...	@@ -2335,6 +2342,53 @@ public:	...	@@ -2335,6 +2342,53 @@ public:
2335	#endif // _LIBCPP_NO_RTTI	2342	#endif // _LIBCPP_NO_RTTI
2336	};	2343	};
2337		2344
		2345	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
		2346	template<class _Rp, class ..._Ap>
		2347	function(_Rp(*)(_Ap...)) -> function<_Rp(_Ap...)>;
		2348
		2349	template<class _Fp>
		2350	struct __strip_signature;
		2351
		2352	template<class _Rp, class _Gp, class ..._Ap>
		2353	struct __strip_signature<_Rp (_Gp::*) (_Ap...)> { using type = _Rp(_Ap...); };
		2354	template<class _Rp, class _Gp, class ..._Ap>
		2355	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const> { using type = _Rp(_Ap...); };
		2356	template<class _Rp, class _Gp, class ..._Ap>
		2357	struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile> { using type = _Rp(_Ap...); };
		2358	template<class _Rp, class _Gp, class ..._Ap>
		2359	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile> { using type = _Rp(_Ap...); };
		2360
		2361	template<class _Rp, class _Gp, class ..._Ap>
		2362	struct __strip_signature<_Rp (_Gp::*) (_Ap...) &> { using type = _Rp(_Ap...); };
		2363	template<class _Rp, class _Gp, class ..._Ap>
		2364	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const &> { using type = _Rp(_Ap...); };
		2365	template<class _Rp, class _Gp, class ..._Ap>
		2366	struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile &> { using type = _Rp(_Ap...); };
		2367	template<class _Rp, class _Gp, class ..._Ap>
		2368	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile &> { using type = _Rp(_Ap...); };
		2369
		2370	template<class _Rp, class _Gp, class ..._Ap>
		2371	struct __strip_signature<_Rp (_Gp::*) (_Ap...) noexcept> { using type = _Rp(_Ap...); };
		2372	template<class _Rp, class _Gp, class ..._Ap>
		2373	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const noexcept> { using type = _Rp(_Ap...); };
		2374	template<class _Rp, class _Gp, class ..._Ap>
		2375	struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile noexcept> { using type = _Rp(_Ap...); };
		2376	template<class _Rp, class _Gp, class ..._Ap>
		2377	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile noexcept> { using type = _Rp(_Ap...); };
		2378
		2379	template<class _Rp, class _Gp, class ..._Ap>
		2380	struct __strip_signature<_Rp (_Gp::*) (_Ap...) & noexcept> { using type = _Rp(_Ap...); };
		2381	template<class _Rp, class _Gp, class ..._Ap>
		2382	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const & noexcept> { using type = _Rp(_Ap...); };
		2383	template<class _Rp, class _Gp, class ..._Ap>
		2384	struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile & noexcept> { using type = _Rp(_Ap...); };
		2385	template<class _Rp, class _Gp, class ..._Ap>
		2386	struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile & noexcept> { using type = _Rp(_Ap...); };
		2387
		2388	template<class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
		2389	function(_Fp) -> function<_Stripped>;
		2390	#endif // !_LIBCPP_HAS_NO_DEDUCTION_GUIDES
		2391
2338	template<class _Rp, class ..._ArgTypes>	2392	template<class _Rp, class ..._ArgTypes>
2339	function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {}	2393	function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {}
2340		2394

lib/libcxx/include/future+8-8

...	@@ -611,7 +611,7 @@ __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) c	...	@@ -611,7 +611,7 @@ __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) c
611	}	611	}
612		612
613	template <class _Rp>	613	template <class _Rp>
614	class _LIBCPP_AVAILABILITY_FUTURE __assoc_state	614	class _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_HIDDEN __assoc_state
615	: public __assoc_sub_state	615	: public __assoc_sub_state
616	{	616	{
617	typedef __assoc_sub_state base;	617	typedef __assoc_sub_state base;
...	@@ -1060,7 +1060,7 @@ template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;	...	@@ -1060,7 +1060,7 @@ template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;
1060	template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;	1060	template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;
1061		1061
1062	template <class _Rp, class _Fp>	1062	template <class _Rp, class _Fp>
1063	future<_Rp>	1063	_LIBCPP_INLINE_VISIBILITY future<_Rp>
1064	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES	1064	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1065	__make_deferred_assoc_state(_Fp&& __f);	1065	__make_deferred_assoc_state(_Fp&& __f);
1066	#else	1066	#else
...	@@ -1068,7 +1068,7 @@ __make_deferred_assoc_state(_Fp __f);	...	@@ -1068,7 +1068,7 @@ __make_deferred_assoc_state(_Fp __f);
1068	#endif	1068	#endif
1069		1069
1070	template <class _Rp, class _Fp>	1070	template <class _Rp, class _Fp>
1071	future<_Rp>	1071	_LIBCPP_INLINE_VISIBILITY future<_Rp>
1072	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES	1072	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1073	__make_async_assoc_state(_Fp&& __f);	1073	__make_async_assoc_state(_Fp&& __f);
1074	#else	1074	#else
...	@@ -1767,9 +1767,9 @@ class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgType	...	@@ -1767,9 +1767,9 @@ class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgType
1767	__compressed_pair<_Fp, _Alloc> __f_;	1767	__compressed_pair<_Fp, _Alloc> __f_;
1768	public:	1768	public:
1769	_LIBCPP_INLINE_VISIBILITY	1769	_LIBCPP_INLINE_VISIBILITY
1770	explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {}	1770	explicit __packaged_task_func(const _Fp& __f) : __f_(__f, __default_init_tag()) {}
1771	_LIBCPP_INLINE_VISIBILITY	1771	_LIBCPP_INLINE_VISIBILITY
1772	explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {}	1772	explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
1773	_LIBCPP_INLINE_VISIBILITY	1773	_LIBCPP_INLINE_VISIBILITY
1774	__packaged_task_func(const _Fp& __f, const _Alloc& __a)	1774	__packaged_task_func(const _Fp& __f, const _Alloc& __a)
1775	: __f_(__f, __a) {}	1775	: __f_(__f, __a) {}
...	@@ -2266,7 +2266,7 @@ struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>	...	@@ -2266,7 +2266,7 @@ struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
2266	: public true_type {};	2266	: public true_type {};
2267		2267
2268	template <class _Rp, class _Fp>	2268	template <class _Rp, class _Fp>
2269	future<_Rp>	2269	_LIBCPP_INLINE_VISIBILITY future<_Rp>
2270	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES	2270	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2271	__make_deferred_assoc_state(_Fp&& __f)	2271	__make_deferred_assoc_state(_Fp&& __f)
2272	#else	2272	#else
...	@@ -2279,7 +2279,7 @@ __make_deferred_assoc_state(_Fp __f)	...	@@ -2279,7 +2279,7 @@ __make_deferred_assoc_state(_Fp __f)
2279	}	2279	}
2280		2280
2281	template <class _Rp, class _Fp>	2281	template <class _Rp, class _Fp>
2282	future<_Rp>	2282	_LIBCPP_INLINE_VISIBILITY future<_Rp>
2283	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES	2283	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2284	__make_async_assoc_state(_Fp&& __f)	2284	__make_async_assoc_state(_Fp&& __f)
2285	#else	2285	#else
...	@@ -2293,7 +2293,7 @@ __make_async_assoc_state(_Fp __f)	...	@@ -2293,7 +2293,7 @@ __make_async_assoc_state(_Fp __f)
2293	}	2293	}
2294		2294
2295	template <class _Fp, class... _Args>	2295	template <class _Fp, class... _Args>
2296	class __async_func	2296	class _LIBCPP_HIDDEN __async_func
2297	{	2297	{
2298	tuple<_Fp, _Args...> __f_;	2298	tuple<_Fp, _Args...> __f_;
2299		2299

lib/libcxx/include/istream+1-1

...	@@ -1619,7 +1619,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)	...	@@ -1619,7 +1619,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
1619	__is.rdbuf()->sbumpc();	1619	__is.rdbuf()->sbumpc();
1620	}	1620	}
1621	__x = bitset<_Size>(__str);	1621	__x = bitset<_Size>(__str);
1622	if (__c == 0)	1622	if (_Size > 0 && __c == 0)
1623	__state \|= ios_base::failbit;	1623	__state \|= ios_base::failbit;
1624	#ifndef _LIBCPP_NO_EXCEPTIONS	1624	#ifndef _LIBCPP_NO_EXCEPTIONS
1625	}	1625	}

lib/libcxx/include/iterator+83-15

 @@ -434,12 +434,65 @@ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
 #endif
 _LIBCPP_BEGIN_NAMESPACE_STD
+template <class _Iter>
+struct _LIBCPP_TEMPLATE_VIS iterator_traits;
 struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag       : public input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};
+#if _LIBCPP_STD_VER > 17
+// TODO(EricWF)  contiguous_iterator_tag is provided as an extension prior to
+//  C++20 to allow optimizations for users providing wrapped iterator types.
+struct _LIBCPP_TEMPLATE_VIS contiguous_iterator_tag: public random_access_iterator_tag { };
+#endif
+template <class _Iter>
+struct __iter_traits_cache {
+  using type = _If<
+    __is_primary_template<iterator_traits<_Iter> >::value,
+    _Iter,
+    iterator_traits<_Iter>
+  >;
+};
+template <class _Iter>
+using _ITER_TRAITS = typename __iter_traits_cache<_Iter>::type;
+struct __iter_concept_concept_test {
+  template <class _Iter>
+  using _Apply = typename _ITER_TRAITS<_Iter>::iterator_concept;
+};
+struct __iter_concept_category_test {
+  template <class _Iter>
+  using _Apply = typename _ITER_TRAITS<_Iter>::iterator_category;
+};
+struct __iter_concept_random_fallback {
+  template <class _Iter>
+  using _Apply = _EnableIf<
+                          __is_primary_template<iterator_traits<_Iter> >::value,
+                          random_access_iterator_tag
+                        >;
+};
+template <class _Iter, class _Tester> struct __test_iter_concept
+    : _IsValidExpansion<_Tester::template _Apply, _Iter>,
+      _Tester
+{
+};
+template <class _Iter>
+struct __iter_concept_cache {
+  using type = _Or<
+    __test_iter_concept<_Iter, __iter_concept_concept_test>,
+    __test_iter_concept<_Iter, __iter_concept_category_test>,
+    __test_iter_concept<_Iter, __iter_concept_random_fallback>
+  >;
+};
+template <class _Iter>
+using _ITER_CONCEPT = typename __iter_concept_cache<_Iter>::type::template _Apply<_Iter>;
 template <class _Tp>
 struct __has_iterator_typedefs
 @@ -500,7 +553,10 @@ struct __iterator_traits<_Iter, true>
 template <class _Iter>
 struct _LIBCPP_TEMPLATE_VIS iterator_traits
-    : __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> {};
+    : __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> {
+  using __primary_template = iterator_traits;
+};
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
 @@ -510,6 +566,9 @@ struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
     typedef _Tp* pointer;
     typedef _Tp& reference;
     typedef random_access_iterator_tag iterator_category;
+#if _LIBCPP_STD_VER > 17
+    typedef contiguous_iterator_tag    iterator_concept;
+#endif
 };
 template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value>
 @@ -521,19 +580,28 @@ template <class _Tp, class _Up>
 struct __has_iterator_category_convertible_to<_Tp, _Up, false> : public false_type {};
 template <class _Tp>
-struct __is_input_iterator : public __has_iterator_category_convertible_to<_Tp, input_iterator_tag> {};
+struct __is_cpp17_input_iterator : public __has_iterator_category_convertible_to<_Tp, input_iterator_tag> {};
 template <class _Tp>
-struct __is_forward_iterator : public __has_iterator_category_convertible_to<_Tp, forward_iterator_tag> {};
+struct __is_cpp17_forward_iterator : public __has_iterator_category_convertible_to<_Tp, forward_iterator_tag> {};
 template <class _Tp>
-struct __is_bidirectional_iterator : public __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag> {};
+struct __is_cpp17_bidirectional_iterator : public __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag> {};
 template <class _Tp>
-struct __is_random_access_iterator : public __has_iterator_category_convertible_to<_Tp, random_access_iterator_tag> {};
+struct __is_cpp17_random_access_iterator : public __has_iterator_category_convertible_to<_Tp, random_access_iterator_tag> {};
+#if _LIBCPP_STD_VER > 17
+template <class _Tp>
+struct __is_cpp17_contiguous_iterator : public __has_iterator_category_convertible_to<_Tp, contiguous_iterator_tag> {};
+#else
+template <class _Tp>
+struct __is_cpp17_contiguous_iterator : public false_type {};
+#endif
 template <class _Tp>
-struct __is_exactly_input_iterator
+struct __is_exactly_cpp17_input_iterator
     : public integral_constant<bool,
          __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value &&
         !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value> {};
 @@ -600,7 +668,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 void advance(_InputIter& __i,
              typename iterator_traits<_InputIter>::difference_type __n)
 {
-    _LIBCPP_ASSERT(__n >= 0 || __is_bidirectional_iterator<_InputIter>::value,
+    _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
                        "Attempt to advance(it, -n) on a non-bidi iterator");
     __advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
 }
 @@ -636,13 +704,13 @@ template <class _InputIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 typename enable_if
 <
-    __is_input_iterator<_InputIter>::value,
+    __is_cpp17_input_iterator<_InputIter>::value,
     _InputIter
 >::type
 next(_InputIter __x,
      typename iterator_traits<_InputIter>::difference_type __n = 1)
 {
-    _LIBCPP_ASSERT(__n >= 0 || __is_bidirectional_iterator<_InputIter>::value,
+    _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
                        "Attempt to next(it, -n) on a non-bidi iterator");
     _VSTD::advance(__x, __n);
 @@ -653,13 +721,13 @@ template <class _InputIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 typename enable_if
 <
-    __is_input_iterator<_InputIter>::value,
+    __is_cpp17_input_iterator<_InputIter>::value,
     _InputIter
 >::type
 prev(_InputIter __x,
      typename iterator_traits<_InputIter>::difference_type __n = 1)
 {
-    _LIBCPP_ASSERT(__n <= 0 || __is_bidirectional_iterator<_InputIter>::value,
+    _LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
                        "Attempt to prev(it, +n) on a non-bidi iterator");
     _VSTD::advance(__x, -__n);
     return __x;
 @@ -1304,8 +1372,8 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
 __wrap_iter<_Iter>
 operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT;
-template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY copy(_Ip, _Ip, _Op);
+template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 copy(_Ip, _Ip, _Op);
-template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY copy_backward(_B1, _B1, _B2);
+template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 copy_backward(_B1, _B1, _B2);
 template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY move(_Ip, _Ip, _Op);
 template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY move_backward(_B1, _B1, _B2);
 @@ -1515,8 +1583,8 @@ private:
     __wrap_iter<_Iter1>
     operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT;
-    template <class _Ip, class _Op> friend _Op copy(_Ip, _Ip, _Op);
+    template <class _Ip, class _Op> friend _LIBCPP_CONSTEXPR_AFTER_CXX17 _Op copy(_Ip, _Ip, _Op);
-    template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
+    template <class _B1, class _B2> friend _LIBCPP_CONSTEXPR_AFTER_CXX17 _B2 copy_backward(_B1, _B1, _B2);
     template <class _Ip, class _Op> friend _Op move(_Ip, _Ip, _Op);
     template <class _B1, class _B2> friend _B2 move_backward(_B1, _B1, _B2);

lib/libcxx/include/list+10-10

...	@@ -715,7 +715,7 @@ template <class _Tp, class _Alloc>	...	@@ -715,7 +715,7 @@ template <class _Tp, class _Alloc>
715	inline	715	inline
716	__list_imp<_Tp, _Alloc>::__list_imp()	716	__list_imp<_Tp, _Alloc>::__list_imp()
717	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)	717	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
718	: __size_alloc_(0)	718	: __size_alloc_(0, __default_init_tag())
719	{	719	{
720	}	720	}
721		721
...	@@ -887,10 +887,10 @@ public:	...	@@ -887,10 +887,10 @@ public:
887	list(size_type __n, const value_type& __x, const allocator_type& __a);	887	list(size_type __n, const value_type& __x, const allocator_type& __a);
888	template <class _InpIter>	888	template <class _InpIter>
889	list(_InpIter __f, _InpIter __l,	889	list(_InpIter __f, _InpIter __l,
890	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);	890	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0);
891	template <class _InpIter>	891	template <class _InpIter>
892	list(_InpIter __f, _InpIter __l, const allocator_type& __a,	892	list(_InpIter __f, _InpIter __l, const allocator_type& __a,
893	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);	893	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0);
894		894
895	list(const list& __c);	895	list(const list& __c);
896	list(const list& __c, const allocator_type& __a);	896	list(const list& __c, const allocator_type& __a);
...	@@ -922,7 +922,7 @@ public:	...	@@ -922,7 +922,7 @@ public:
922		922
923	template <class _InpIter>	923	template <class _InpIter>
924	void assign(_InpIter __f, _InpIter __l,	924	void assign(_InpIter __f, _InpIter __l,
925	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);	925	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0);
926	void assign(size_type __n, const value_type& __x);	926	void assign(size_type __n, const value_type& __x);
927		927
928	_LIBCPP_INLINE_VISIBILITY	928	_LIBCPP_INLINE_VISIBILITY
...	@@ -1039,7 +1039,7 @@ public:	...	@@ -1039,7 +1039,7 @@ public:
1039	iterator insert(const_iterator __p, size_type __n, const value_type& __x);	1039	iterator insert(const_iterator __p, size_type __n, const value_type& __x);
1040	template <class _InpIter>	1040	template <class _InpIter>
1041	iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,	1041	iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
1042	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);	1042	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0);
1043		1043
1044	_LIBCPP_INLINE_VISIBILITY	1044	_LIBCPP_INLINE_VISIBILITY
1045	void swap(list& __c)	1045	void swap(list& __c)
...	@@ -1252,7 +1252,7 @@ list<_Tp, _Alloc>::list(size_type __n, const value_type& __x, const allocator_ty	...	@@ -1252,7 +1252,7 @@ list<_Tp, _Alloc>::list(size_type __n, const value_type& __x, const allocator_ty
1252	template <class _Tp, class _Alloc>	1252	template <class _Tp, class _Alloc>
1253	template <class _InpIter>	1253	template <class _InpIter>
1254	list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,	1254	list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,
1255	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)	1255	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*)
1256	{	1256	{
1257	#if _LIBCPP_DEBUG_LEVEL >= 2	1257	#if _LIBCPP_DEBUG_LEVEL >= 2
1258	__get_db()->__insert_c(this);	1258	__get_db()->__insert_c(this);
...	@@ -1264,7 +1264,7 @@ list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,	...	@@ -1264,7 +1264,7 @@ list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,
1264	template <class _Tp, class _Alloc>	1264	template <class _Tp, class _Alloc>
1265	template <class _InpIter>	1265	template <class _InpIter>
1266	list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a,	1266	list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a,
1267	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)	1267	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*)
1268	: base(__a)	1268	: base(__a)
1269	{	1269	{
1270	#if _LIBCPP_DEBUG_LEVEL >= 2	1270	#if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -1403,7 +1403,7 @@ template <class _Tp, class _Alloc>	...	@@ -1403,7 +1403,7 @@ template <class _Tp, class _Alloc>
1403	template <class _InpIter>	1403	template <class _InpIter>
1404	void	1404	void
1405	list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l,	1405	list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l,
1406	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)	1406	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*)
1407	{	1407	{
1408	iterator __i = begin();	1408	iterator __i = begin();
1409	iterator __e = end();	1409	iterator __e = end();
...	@@ -1532,7 +1532,7 @@ template <class _Tp, class _Alloc>	...	@@ -1532,7 +1532,7 @@ template <class _Tp, class _Alloc>
1532	template <class _InpIter>	1532	template <class _InpIter>
1533	typename list<_Tp, _Alloc>::iterator	1533	typename list<_Tp, _Alloc>::iterator
1534	list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,	1534	list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
1535	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)	1535	typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*)
1536	{	1536	{
1537	#if _LIBCPP_DEBUG_LEVEL >= 2	1537	#if _LIBCPP_DEBUG_LEVEL >= 2
1538	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,	1538	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
...	@@ -2211,7 +2211,7 @@ list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)	...	@@ -2211,7 +2211,7 @@ list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
2211	__i = __j;	2211	__i = __j;
2212	}	2212	}
2213	}	2213	}
2214		2214
2215	return (__remove_return_type) __deleted_nodes.size();	2215	return (__remove_return_type) __deleted_nodes.size();
2216	}	2216	}
2217		2217

lib/libcxx/include/map+12-12

lib/libcxx/include/math.h+4

 @@ -510,7 +510,11 @@ _LIBCPP_INLINE_VISIBILITY
 bool
 __libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
 {
+#if __has_builtin(__builtin_isnan)
+    return __builtin_isnan(__lcpp_x);
+#else
     return isnan(__lcpp_x);
+#endif
 }
 #undef isnan

lib/libcxx/include/memory+142-384

...	@@ -662,7 +662,6 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);	...	@@ -662,7 +662,6 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
662	#include <tuple>	662	#include <tuple>
663	#include <stdexcept>	663	#include <stdexcept>
664	#include <cstring>	664	#include <cstring>
665	#include <cassert>
666	#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)	665	#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
667	# include <atomic>	666	# include <atomic>
668	#endif	667	#endif
...	@@ -1099,40 +1098,51 @@ struct __const_void_pointer<_Ptr, _Alloc, false>	...	@@ -1099,40 +1098,51 @@ struct __const_void_pointer<_Ptr, _Alloc, false>
1099	#endif	1098	#endif
1100	};	1099	};
1101		1100
		1101
		1102	template <bool _UsePointerTraits> struct __to_address_helper;
		1103
		1104	template <> struct __to_address_helper<true> {
		1105	template <class _Pointer>
		1106	using __return_type = decltype(pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()));
		1107
		1108	template <class _Pointer>
		1109	_LIBCPP_CONSTEXPR
		1110	static __return_type<_Pointer>
		1111	__do_it(const _Pointer &__p) _NOEXCEPT { return pointer_traits<_Pointer>::to_address(__p); }
		1112	};
		1113
		1114	template <class _Pointer, bool _Dummy = true>
		1115	using __choose_to_address = __to_address_helper<_IsValidExpansion<__to_address_helper<_Dummy>::template __return_type, _Pointer>::value>;
		1116
		1117
1102	template <class _Tp>	1118	template <class _Tp>
1103	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR	1119	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1104	_Tp*	1120	_Tp*
1105	__to_raw_pointer(_Tp* __p) _NOEXCEPT	1121	__to_address(_Tp* __p) _NOEXCEPT
1106	{	1122	{
		1123	static_assert(!is_function<_Tp>::value, "_Tp is a function type");
1107	return __p;	1124	return __p;
1108	}	1125	}
1109		1126
1110	#if _LIBCPP_STD_VER <= 17
1111	template <class _Pointer>
1112	inline _LIBCPP_INLINE_VISIBILITY
1113	typename pointer_traits<_Pointer>::element_type*
1114	__to_raw_pointer(_Pointer __p) _NOEXCEPT
1115	{
1116	return _VSTD::__to_raw_pointer(__p.operator->());
1117	}
1118	#else
1119	template <class _Pointer>	1127	template <class _Pointer>
1120	inline _LIBCPP_INLINE_VISIBILITY	1128	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1121	auto	1129	typename __choose_to_address<_Pointer>::template __return_type<_Pointer>
1122	__to_raw_pointer(const _Pointer& __p) _NOEXCEPT	1130	__to_address(const _Pointer& __p) _NOEXCEPT {
1123	-> decltype(pointer_traits<_Pointer>::to_address(__p))	1131	return __choose_to_address<_Pointer>::__do_it(__p);
1124	{
1125	return pointer_traits<_Pointer>::to_address(__p);
1126	}	1132	}
1127		1133
1128	template <class _Pointer, class... _None>	1134	template <> struct __to_address_helper<false> {
1129	inline _LIBCPP_INLINE_VISIBILITY	1135	template <class _Pointer>
1130	auto	1136	using __return_type = typename pointer_traits<_Pointer>::element_type*;
1131	__to_raw_pointer(const _Pointer& __p, _None...) _NOEXCEPT
1132	{
1133	return _VSTD::__to_raw_pointer(__p.operator->());
1134	}
1135		1137
		1138	template <class _Pointer>
		1139	_LIBCPP_CONSTEXPR
		1140	static __return_type<_Pointer>
		1141	__do_it(const _Pointer &__p) _NOEXCEPT { return std::__to_address(__p.operator->()); }
		1142	};
		1143
		1144
		1145	#if _LIBCPP_STD_VER > 17
1136	template <class _Tp>	1146	template <class _Tp>
1137	inline _LIBCPP_INLINE_VISIBILITY constexpr	1147	inline _LIBCPP_INLINE_VISIBILITY constexpr
1138	_Tp*	1148	_Tp*
...	@@ -1147,7 +1157,7 @@ inline _LIBCPP_INLINE_VISIBILITY	...	@@ -1147,7 +1157,7 @@ inline _LIBCPP_INLINE_VISIBILITY
1147	auto	1157	auto
1148	to_address(const _Pointer& __p) _NOEXCEPT	1158	to_address(const _Pointer& __p) _NOEXCEPT
1149	{	1159	{
1150	return _VSTD::__to_raw_pointer(__p);	1160	return _VSTD::__to_address(__p);
1151	}	1161	}
1152	#endif	1162	#endif
1153		1163
...	@@ -1507,6 +1517,31 @@ struct __is_default_allocator : false_type {};	...	@@ -1507,6 +1517,31 @@ struct __is_default_allocator : false_type {};
1507	template <class _Tp>	1517	template <class _Tp>
1508	struct __is_default_allocator<_VSTD::allocator<_Tp> > : true_type {};	1518	struct __is_default_allocator<_VSTD::allocator<_Tp> > : true_type {};
1509		1519
		1520
		1521
		1522	template <class _Alloc,
		1523	bool = __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value && !__is_default_allocator<_Alloc>::value
		1524	>
		1525	struct __is_cpp17_move_insertable;
		1526	template <class _Alloc>
		1527	struct __is_cpp17_move_insertable<_Alloc, true> : std::true_type {};
		1528	template <class _Alloc>
		1529	struct __is_cpp17_move_insertable<_Alloc, false> : std::is_move_constructible<typename _Alloc::value_type> {};
		1530
		1531	template <class _Alloc,
		1532	bool = __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value && !__is_default_allocator<_Alloc>::value
		1533	>
		1534	struct __is_cpp17_copy_insertable;
		1535	template <class _Alloc>
		1536	struct __is_cpp17_copy_insertable<_Alloc, true> : __is_cpp17_move_insertable<_Alloc> {};
		1537	template <class _Alloc>
		1538	struct __is_cpp17_copy_insertable<_Alloc, false> : integral_constant<bool,
		1539	std::is_copy_constructible<typename _Alloc::value_type>::value &&
		1540	__is_cpp17_move_insertable<_Alloc>::value>
		1541	{};
		1542
		1543
		1544
1510	template <class _Alloc>	1545	template <class _Alloc>
1511	struct _LIBCPP_TEMPLATE_VIS allocator_traits	1546	struct _LIBCPP_TEMPLATE_VIS allocator_traits
1512	{	1547	{
...	@@ -1609,10 +1644,18 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits	...	@@ -1609,10 +1644,18 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
1609	_LIBCPP_INLINE_VISIBILITY	1644	_LIBCPP_INLINE_VISIBILITY
1610	static	1645	static
1611	void	1646	void
1612	__construct_forward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2)	1647	__construct_forward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2)
1613	{	1648	{
		1649	static_assert(__is_cpp17_move_insertable<allocator_type>::value,
		1650	"The specified type does not meet the requirements of Cpp17MoveInsertible");
1614	for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)	1651	for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
1615	construct(__a, _VSTD::__to_raw_pointer(__begin2), _VSTD::move_if_noexcept(*__begin1));	1652	construct(__a, _VSTD::__to_address(__begin2),
		1653	#ifdef _LIBCPP_NO_EXCEPTIONS
		1654	_VSTD::move(*__begin1)
		1655	#else
		1656	_VSTD::move_if_noexcept(*__begin1)
		1657	#endif
		1658	);
1616	}	1659	}
1617		1660
1618	template <class _Tp>	1661	template <class _Tp>
...	@@ -1625,7 +1668,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits	...	@@ -1625,7 +1668,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
1625	is_trivially_move_constructible<_Tp>::value,	1668	is_trivially_move_constructible<_Tp>::value,
1626	void	1669	void
1627	>::type	1670	>::type
1628	__construct_forward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)	1671	__construct_forward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
1629	{	1672	{
1630	ptrdiff_t _Np = __end1 - __begin1;	1673	ptrdiff_t _Np = __end1 - __begin1;
1631	if (_Np > 0)	1674	if (_Np > 0)
...	@@ -1642,7 +1685,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits	...	@@ -1642,7 +1685,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
1642	__construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2)	1685	__construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2)
1643	{	1686	{
1644	for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)	1687	for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
1645	construct(__a, _VSTD::__to_raw_pointer(__begin2), *__begin1);	1688	construct(__a, _VSTD::__to_address(__begin2), *__begin1);
1646	}	1689	}
1647		1690
1648	template <class _SourceTp, class _DestTp,	1691	template <class _SourceTp, class _DestTp,
...	@@ -1672,12 +1715,20 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits	...	@@ -1672,12 +1715,20 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
1672	_LIBCPP_INLINE_VISIBILITY	1715	_LIBCPP_INLINE_VISIBILITY
1673	static	1716	static
1674	void	1717	void
1675	__construct_backward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2)	1718	__construct_backward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2)
1676	{	1719	{
		1720	static_assert(__is_cpp17_move_insertable<allocator_type>::value,
		1721	"The specified type does not meet the requirements of Cpp17MoveInsertable");
1677	while (__end1 != __begin1)	1722	while (__end1 != __begin1)
1678	{	1723	{
1679	construct(__a, _VSTD::__to_raw_pointer(__end2-1), _VSTD::move_if_noexcept(*--__end1));	1724	construct(__a, _VSTD::__to_address(__end2 - 1),
1680	--__end2;	1725	#ifdef _LIBCPP_NO_EXCEPTIONS
		1726	_VSTD::move(*--__end1)
		1727	#else
		1728	_VSTD::move_if_noexcept(*--__end1)
		1729	#endif
		1730	);
		1731	--__end2;
1681	}	1732	}
1682	}	1733	}
1683		1734
...	@@ -1691,7 +1742,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits	...	@@ -1691,7 +1742,7 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
1691	is_trivially_move_constructible<_Tp>::value,	1742	is_trivially_move_constructible<_Tp>::value,
1692	void	1743	void
1693	>::type	1744	>::type
1694	__construct_backward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)	1745	__construct_backward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)
1695	{	1746	{
1696	ptrdiff_t _Np = __end1 - __begin1;	1747	ptrdiff_t _Np = __end1 - __begin1;
1697	__end2 -= _Np;	1748	__end2 -= _Np;
...	@@ -2127,6 +2178,10 @@ public:	...	@@ -2127,6 +2178,10 @@ public:
2127	};	2178	};
2128	#endif	2179	#endif
2129		2180
		2181	// Tag used to default initialize one or both of the pair's elements.
		2182	struct __default_init_tag {};
		2183	struct __value_init_tag {};
		2184
2130	template <class _Tp, int _Idx,	2185	template <class _Tp, int _Idx,
2131	bool _CanBeEmptyBase =	2186	bool _CanBeEmptyBase =
2132	is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value>	2187	is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value>
...	@@ -2135,30 +2190,31 @@ struct __compressed_pair_elem {	...	@@ -2135,30 +2190,31 @@ struct __compressed_pair_elem {
2135	typedef _Tp& reference;	2190	typedef _Tp& reference;
2136	typedef const _Tp& const_reference;	2191	typedef const _Tp& const_reference;
2137		2192
2138	#ifndef _LIBCPP_CXX03_LANG	2193	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
2139	_LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() : __value_() {}	2194	__compressed_pair_elem(__default_init_tag) {}
		2195	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
		2196	__compressed_pair_elem(__value_init_tag) : __value_() {}
2140		2197
2141	template <class _Up, class = typename enable_if<	2198	template <class _Up, class = typename enable_if<
2142	!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value	2199	!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value
2143	>::type>	2200	>::type>
2144	_LIBCPP_INLINE_VISIBILITY	2201	_LIBCPP_INLINE_VISIBILITY
2145	constexpr explicit	2202	_LIBCPP_CONSTEXPR explicit
2146	__compressed_pair_elem(_Up&& __u)	2203	__compressed_pair_elem(_Up&& __u)
2147	: __value_(_VSTD::forward<_Up>(__u))	2204	: __value_(_VSTD::forward<_Up>(__u))
2148	{	2205	{
2149	}	2206	}
2150		2207
		2208
		2209	#ifndef _LIBCPP_CXX03_LANG
2151	template <class... _Args, size_t... _Indexes>	2210	template <class... _Args, size_t... _Indexes>
2152	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14	2211	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
2153	__compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,	2212	__compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
2154	__tuple_indices<_Indexes...>)	2213	__tuple_indices<_Indexes...>)
2155	: __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}	2214	: __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
2156	#else
2157	_LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_() {}
2158	_LIBCPP_INLINE_VISIBILITY
2159	__compressed_pair_elem(_ParamT __p) : __value_(std::forward<_ParamT>(__p)) {}
2160	#endif	2215	#endif
2161		2216
		2217
2162	_LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; }	2218	_LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; }
2163	_LIBCPP_INLINE_VISIBILITY	2219	_LIBCPP_INLINE_VISIBILITY
2164	const_reference __get() const _NOEXCEPT { return __value_; }	2220	const_reference __get() const _NOEXCEPT { return __value_; }
...	@@ -2174,28 +2230,27 @@ struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {	...	@@ -2174,28 +2230,27 @@ struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
2174	typedef const _Tp& const_reference;	2230	typedef const _Tp& const_reference;
2175	typedef _Tp __value_type;	2231	typedef _Tp __value_type;
2176		2232
2177	#ifndef _LIBCPP_CXX03_LANG	2233	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __compressed_pair_elem() = default;
2178	_LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() = default;	2234	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
		2235	__compressed_pair_elem(__default_init_tag) {}
		2236	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
		2237	__compressed_pair_elem(__value_init_tag) : __value_type() {}
2179		2238
2180	template <class _Up, class = typename enable_if<	2239	template <class _Up, class = typename enable_if<
2181	!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value	2240	!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value
2182	>::type>	2241	>::type>
2183	_LIBCPP_INLINE_VISIBILITY	2242	_LIBCPP_INLINE_VISIBILITY
2184	constexpr explicit	2243	_LIBCPP_CONSTEXPR explicit
2185	__compressed_pair_elem(_Up&& __u)	2244	__compressed_pair_elem(_Up&& __u)
2186	: __value_type(_VSTD::forward<_Up>(__u))	2245	: __value_type(_VSTD::forward<_Up>(__u))
2187	{}	2246	{}
2188		2247
		2248	#ifndef _LIBCPP_CXX03_LANG
2189	template <class... _Args, size_t... _Indexes>	2249	template <class... _Args, size_t... _Indexes>
2190	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14	2250	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
2191	__compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,	2251	__compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
2192	__tuple_indices<_Indexes...>)	2252	__tuple_indices<_Indexes...>)
2193	: __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}	2253	: __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
2194	#else
2195	_LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_type() {}
2196	_LIBCPP_INLINE_VISIBILITY
2197	__compressed_pair_elem(_ParamT __p)
2198	: __value_type(std::forward<_ParamT>(__p)) {}
2199	#endif	2254	#endif
2200		2255
2201	_LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; }	2256	_LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; }
...	@@ -2203,9 +2258,6 @@ struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {	...	@@ -2203,9 +2258,6 @@ struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
2203	const_reference __get() const _NOEXCEPT { return *this; }	2258	const_reference __get() const _NOEXCEPT { return *this; }
2204	};	2259	};
2205		2260
2206	// Tag used to construct the second element of the compressed pair.
2207	struct __second_tag {};
2208
2209	template <class _T1, class _T2>	2261	template <class _T1, class _T2>
2210	class __compressed_pair : private __compressed_pair_elem<_T1, 0>,	2262	class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
2211	private __compressed_pair_elem<_T2, 1> {	2263	private __compressed_pair_elem<_T2, 1> {
...	@@ -2222,33 +2274,21 @@ class __compressed_pair : private __compressed_pair_elem<_T1, 0>,	...	@@ -2222,33 +2274,21 @@ class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
2222	"implementation for this configuration");	2274	"implementation for this configuration");
2223		2275
2224	public:	2276	public:
2225	#ifndef _LIBCPP_CXX03_LANG	2277	template <bool _Dummy = true,
2226	template <bool _Dummy = true,
2227	class = typename enable_if<	2278	class = typename enable_if<
2228	__dependent_type<is_default_constructible<_T1>, _Dummy>::value &&	2279	__dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
2229	__dependent_type<is_default_constructible<_T2>, _Dummy>::value	2280	__dependent_type<is_default_constructible<_T2>, _Dummy>::value
2230	>::type	2281	>::type
2231	>	2282	>
2232	_LIBCPP_INLINE_VISIBILITY	2283	_LIBCPP_INLINE_VISIBILITY
2233	constexpr __compressed_pair() {}	2284	_LIBCPP_CONSTEXPR __compressed_pair() : _Base1(__value_init_tag()), _Base2(__value_init_tag()) {}
2234
2235	template <class _Tp, typename enable_if<!is_same<typename decay<_Tp>::type,
2236	__compressed_pair>::value,
2237	bool>::type = true>
2238	_LIBCPP_INLINE_VISIBILITY constexpr explicit
2239	__compressed_pair(_Tp&& __t)
2240	: _Base1(std::forward<_Tp>(__t)), _Base2() {}
2241
2242	template <class _Tp>
2243	_LIBCPP_INLINE_VISIBILITY constexpr
2244	__compressed_pair(__second_tag, _Tp&& __t)
2245	: _Base1(), _Base2(std::forward<_Tp>(__t)) {}
2246		2285
2247	template <class _U1, class _U2>	2286	template <class _U1, class _U2>
2248	_LIBCPP_INLINE_VISIBILITY constexpr	2287	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
2249	__compressed_pair(_U1&& __t1, _U2&& __t2)	2288	__compressed_pair(_U1&& __t1, _U2&& __t2)
2250	: _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {}	2289	: _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {}
2251		2290
		2291	#ifndef _LIBCPP_CXX03_LANG
2252	template <class... _Args1, class... _Args2>	2292	template <class... _Args1, class... _Args2>
2253	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14	2293	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
2254	__compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,	2294	__compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
...	@@ -2257,21 +2297,6 @@ public:	...	@@ -2257,21 +2297,6 @@ public:
2257	typename __make_tuple_indices<sizeof...(_Args1)>::type()),	2297	typename __make_tuple_indices<sizeof...(_Args1)>::type()),
2258	_Base2(__pc, _VSTD::move(__second_args),	2298	_Base2(__pc, _VSTD::move(__second_args),
2259	typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}	2299	typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}
2260
2261	#else
2262	_LIBCPP_INLINE_VISIBILITY
2263	__compressed_pair() {}
2264
2265	_LIBCPP_INLINE_VISIBILITY explicit
2266	__compressed_pair(_T1 __t1) : _Base1(_VSTD::forward<_T1>(__t1)) {}
2267
2268	_LIBCPP_INLINE_VISIBILITY
2269	__compressed_pair(__second_tag, _T2 __t2)
2270	: _Base1(), _Base2(_VSTD::forward<_T2>(__t2)) {}
2271
2272	_LIBCPP_INLINE_VISIBILITY
2273	__compressed_pair(_T1 __t1, _T2 __t2)
2274	: _Base1(_VSTD::forward<_T1>(__t1)), _Base2(_VSTD::forward<_T2>(__t2)) {}
2275	#endif	2300	#endif
2276		2301
2277	_LIBCPP_INLINE_VISIBILITY	2302	_LIBCPP_INLINE_VISIBILITY
...	@@ -2452,17 +2477,17 @@ public:	...	@@ -2452,17 +2477,17 @@ public:
2452	template <bool _Dummy = true,	2477	template <bool _Dummy = true,
2453	class = _EnableIfDeleterDefaultConstructible<_Dummy> >	2478	class = _EnableIfDeleterDefaultConstructible<_Dummy> >
2454	_LIBCPP_INLINE_VISIBILITY	2479	_LIBCPP_INLINE_VISIBILITY
2455	_LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer()) {}	2480	_LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
2456		2481
2457	template <bool _Dummy = true,	2482	template <bool _Dummy = true,
2458	class = _EnableIfDeleterDefaultConstructible<_Dummy> >	2483	class = _EnableIfDeleterDefaultConstructible<_Dummy> >
2459	_LIBCPP_INLINE_VISIBILITY	2484	_LIBCPP_INLINE_VISIBILITY
2460	_LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer()) {}	2485	_LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
2461		2486
2462	template <bool _Dummy = true,	2487	template <bool _Dummy = true,
2463	class = _EnableIfDeleterDefaultConstructible<_Dummy> >	2488	class = _EnableIfDeleterDefaultConstructible<_Dummy> >
2464	_LIBCPP_INLINE_VISIBILITY	2489	_LIBCPP_INLINE_VISIBILITY
2465	explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p) {}	2490	explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p, __default_init_tag()) {}
2466		2491
2467	template <bool _Dummy = true,	2492	template <bool _Dummy = true,
2468	class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >	2493	class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
...	@@ -2504,7 +2529,7 @@ public:	...	@@ -2504,7 +2529,7 @@ public:
2504	typename enable_if<is_convertible<_Up, _Tp>::value &&	2529	typename enable_if<is_convertible<_Up, _Tp>::value &&
2505	is_same<_Dp, default_delete<_Tp> >::value,	2530	is_same<_Dp, default_delete<_Tp> >::value,
2506	__nat>::type = __nat()) _NOEXCEPT	2531	__nat>::type = __nat()) _NOEXCEPT
2507	: __ptr_(__p.release()) {}	2532	: __ptr_(__p.release(), __default_init_tag()) {}
2508	#endif	2533	#endif
2509		2534
2510	_LIBCPP_INLINE_VISIBILITY	2535	_LIBCPP_INLINE_VISIBILITY
...	@@ -2675,19 +2700,19 @@ public:	...	@@ -2675,19 +2700,19 @@ public:
2675	template <bool _Dummy = true,	2700	template <bool _Dummy = true,
2676	class = _EnableIfDeleterDefaultConstructible<_Dummy> >	2701	class = _EnableIfDeleterDefaultConstructible<_Dummy> >
2677	_LIBCPP_INLINE_VISIBILITY	2702	_LIBCPP_INLINE_VISIBILITY
2678	_LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer()) {}	2703	_LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
2679		2704
2680	template <bool _Dummy = true,	2705	template <bool _Dummy = true,
2681	class = _EnableIfDeleterDefaultConstructible<_Dummy> >	2706	class = _EnableIfDeleterDefaultConstructible<_Dummy> >
2682	_LIBCPP_INLINE_VISIBILITY	2707	_LIBCPP_INLINE_VISIBILITY
2683	_LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer()) {}	2708	_LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
2684		2709
2685	template <class _Pp, bool _Dummy = true,	2710	template <class _Pp, bool _Dummy = true,
2686	class = _EnableIfDeleterDefaultConstructible<_Dummy>,	2711	class = _EnableIfDeleterDefaultConstructible<_Dummy>,
2687	class = _EnableIfPointerConvertible<_Pp> >	2712	class = _EnableIfPointerConvertible<_Pp> >
2688	_LIBCPP_INLINE_VISIBILITY	2713	_LIBCPP_INLINE_VISIBILITY
2689	explicit unique_ptr(_Pp __p) _NOEXCEPT	2714	explicit unique_ptr(_Pp __p) _NOEXCEPT
2690	: __ptr_(__p) {}	2715	: __ptr_(__p, __default_init_tag()) {}
2691		2716
2692	template <class _Pp, bool _Dummy = true,	2717	template <class _Pp, bool _Dummy = true,
2693	class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,	2718	class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
...	@@ -3531,24 +3556,20 @@ class __shared_ptr_emplace	...	@@ -3531,24 +3556,20 @@ class __shared_ptr_emplace
3531	{	3556	{
3532	__compressed_pair<_Alloc, _Tp> __data_;	3557	__compressed_pair<_Alloc, _Tp> __data_;
3533	public:	3558	public:
3534	#ifndef _LIBCPP_HAS_NO_VARIADICS
3535		3559
3536	_LIBCPP_INLINE_VISIBILITY	3560	_LIBCPP_INLINE_VISIBILITY
3537	__shared_ptr_emplace(_Alloc __a)	3561	__shared_ptr_emplace(_Alloc __a)
3538	: __data_(_VSTD::move(__a)) {}	3562	: __data_(_VSTD::move(__a), __value_init_tag()) {}
		3563
3539		3564
		3565	#ifndef _LIBCPP_HAS_NO_VARIADICS
3540	template <class ..._Args>	3566	template <class ..._Args>
3541	_LIBCPP_INLINE_VISIBILITY	3567	_LIBCPP_INLINE_VISIBILITY
3542	__shared_ptr_emplace(_Alloc __a, _Args&& ...__args)	3568	__shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
3543	: __data_(piecewise_construct, _VSTD::forward_as_tuple(__a),	3569	: __data_(piecewise_construct, _VSTD::forward_as_tuple(__a),
3544	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {}	3570	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {}
3545
3546	#else // _LIBCPP_HAS_NO_VARIADICS	3571	#else // _LIBCPP_HAS_NO_VARIADICS
3547		3572
3548	_LIBCPP_INLINE_VISIBILITY
3549	__shared_ptr_emplace(_Alloc __a)
3550	: __data_(__a) {}
3551
3552	template <class _A0>	3573	template <class _A0>
3553	_LIBCPP_INLINE_VISIBILITY	3574	_LIBCPP_INLINE_VISIBILITY
3554	__shared_ptr_emplace(_Alloc __a, _A0& __a0)	3575	__shared_ptr_emplace(_Alloc __a, _A0& __a0)
...	@@ -3831,49 +3852,22 @@ public:	...	@@ -3831,49 +3852,22 @@ public:
3831	: nullptr);}	3852	: nullptr);}
3832	#endif // _LIBCPP_NO_RTTI	3853	#endif // _LIBCPP_NO_RTTI
3833		3854
3834	#ifndef _LIBCPP_HAS_NO_VARIADICS	3855	template<class _Yp, class _CntrlBlk>
3835		3856	static shared_ptr<_Tp>
3836	template<class ..._Args>	3857	__create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl)
3837	static	3858	{
3838	shared_ptr<_Tp>	3859	shared_ptr<_Tp> __r;
3839	make_shared(_Args&& ...__args);	3860	__r.__ptr_ = __p;
		3861	__r.__cntrl_ = __cntrl;
		3862	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
		3863	return __r;
		3864	}
3840		3865
3841	template<class _Alloc, class ..._Args>	3866	template<class _Alloc, class ..._Args>
3842	static	3867	static
3843	shared_ptr<_Tp>	3868	shared_ptr<_Tp>
3844	allocate_shared(const _Alloc& __a, _Args&& ...__args);	3869	allocate_shared(const _Alloc& __a, _Args&& ...__args);
3845		3870
3846	#else // _LIBCPP_HAS_NO_VARIADICS
3847
3848	static shared_ptr<_Tp> make_shared();
3849
3850	template<class _A0>
3851	static shared_ptr<_Tp> make_shared(_A0&);
3852
3853	template<class _A0, class _A1>
3854	static shared_ptr<_Tp> make_shared(_A0&, _A1&);
3855
3856	template<class _A0, class _A1, class _A2>
3857	static shared_ptr<_Tp> make_shared(_A0&, _A1&, _A2&);
3858
3859	template<class _Alloc>
3860	static shared_ptr<_Tp>
3861	allocate_shared(const _Alloc& __a);
3862
3863	template<class _Alloc, class _A0>
3864	static shared_ptr<_Tp>
3865	allocate_shared(const _Alloc& __a, _A0& __a0);
3866
3867	template<class _Alloc, class _A0, class _A1>
3868	static shared_ptr<_Tp>
3869	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1);
3870
3871	template<class _Alloc, class _A0, class _A1, class _A2>
3872	static shared_ptr<_Tp>
3873	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2);
3874
3875	#endif // _LIBCPP_HAS_NO_VARIADICS
3876
3877	private:	3871	private:
3878	template <class _Yp, bool = is_function<_Yp>::value>	3872	template <class _Yp, bool = is_function<_Yp>::value>
3879	struct __shared_ptr_default_allocator	3873	struct __shared_ptr_default_allocator
...	@@ -4186,27 +4180,6 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,	...	@@ -4186,27 +4180,6 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
4186	__r.release();	4180	__r.release();
4187	}	4181	}
4188		4182
4189	#ifndef _LIBCPP_HAS_NO_VARIADICS
4190
4191	template<class _Tp>
4192	template<class ..._Args>
4193	shared_ptr<_Tp>
4194	shared_ptr<_Tp>::make_shared(_Args&& ...__args)
4195	{
4196	static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in make_shared" );
4197	typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
4198	typedef allocator<_CntrlBlk> _A2;
4199	typedef __allocator_destructor<_A2> _D2;
4200	_A2 __a2;
4201	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
4202	::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...);
4203	shared_ptr<_Tp> __r;
4204	__r.__ptr_ = __hold2.get()->get();
4205	__r.__cntrl_ = __hold2.release();
4206	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4207	return __r;
4208	}
4209
4210	template<class _Tp>	4183	template<class _Tp>
4211	template<class _Alloc, class ..._Args>	4184	template<class _Alloc, class ..._Args>
4212	shared_ptr<_Tp>	4185	shared_ptr<_Tp>
...	@@ -4227,165 +4200,6 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)	...	@@ -4227,165 +4200,6 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
4227	return __r;	4200	return __r;
4228	}	4201	}
4229		4202
4230	#else // _LIBCPP_HAS_NO_VARIADICS
4231
4232	template<class _Tp>
4233	shared_ptr<_Tp>
4234	shared_ptr<_Tp>::make_shared()
4235	{
4236	static_assert((is_constructible<_Tp>::value), "Can't construct object in make_shared" );
4237	typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
4238	typedef allocator<_CntrlBlk> _Alloc2;
4239	typedef __allocator_destructor<_Alloc2> _D2;
4240	_Alloc2 __alloc2;
4241	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4242	::new(__hold2.get()) _CntrlBlk(__alloc2);
4243	shared_ptr<_Tp> __r;
4244	__r.__ptr_ = __hold2.get()->get();
4245	__r.__cntrl_ = __hold2.release();
4246	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4247	return __r;
4248	}
4249
4250	template<class _Tp>
4251	template<class _A0>
4252	shared_ptr<_Tp>
4253	shared_ptr<_Tp>::make_shared(_A0& __a0)
4254	{
4255	static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in make_shared" );
4256	typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
4257	typedef allocator<_CntrlBlk> _Alloc2;
4258	typedef __allocator_destructor<_Alloc2> _D2;
4259	_Alloc2 __alloc2;
4260	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4261	::new(__hold2.get()) _CntrlBlk(__alloc2, __a0);
4262	shared_ptr<_Tp> __r;
4263	__r.__ptr_ = __hold2.get()->get();
4264	__r.__cntrl_ = __hold2.release();
4265	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4266	return __r;
4267	}
4268
4269	template<class _Tp>
4270	template<class _A0, class _A1>
4271	shared_ptr<_Tp>
4272	shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1)
4273	{
4274	static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in make_shared" );
4275	typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
4276	typedef allocator<_CntrlBlk> _Alloc2;
4277	typedef __allocator_destructor<_Alloc2> _D2;
4278	_Alloc2 __alloc2;
4279	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4280	::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1);
4281	shared_ptr<_Tp> __r;
4282	__r.__ptr_ = __hold2.get()->get();
4283	__r.__cntrl_ = __hold2.release();
4284	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4285	return __r;
4286	}
4287
4288	template<class _Tp>
4289	template<class _A0, class _A1, class _A2>
4290	shared_ptr<_Tp>
4291	shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1, _A2& __a2)
4292	{
4293	static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in make_shared" );
4294	typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
4295	typedef allocator<_CntrlBlk> _Alloc2;
4296	typedef __allocator_destructor<_Alloc2> _D2;
4297	_Alloc2 __alloc2;
4298	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4299	::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1, __a2);
4300	shared_ptr<_Tp> __r;
4301	__r.__ptr_ = __hold2.get()->get();
4302	__r.__cntrl_ = __hold2.release();
4303	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4304	return __r;
4305	}
4306
4307	template<class _Tp>
4308	template<class _Alloc>
4309	shared_ptr<_Tp>
4310	shared_ptr<_Tp>::allocate_shared(const _Alloc& __a)
4311	{
4312	static_assert((is_constructible<_Tp>::value), "Can't construct object in allocate_shared" );
4313	typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
4314	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
4315	typedef __allocator_destructor<_Alloc2> _D2;
4316	_Alloc2 __alloc2(__a);
4317	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4318	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
4319	_CntrlBlk(__a);
4320	shared_ptr<_Tp> __r;
4321	__r.__ptr_ = __hold2.get()->get();
4322	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
4323	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4324	return __r;
4325	}
4326
4327	template<class _Tp>
4328	template<class _Alloc, class _A0>
4329	shared_ptr<_Tp>
4330	shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0)
4331	{
4332	static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in allocate_shared" );
4333	typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
4334	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
4335	typedef __allocator_destructor<_Alloc2> _D2;
4336	_Alloc2 __alloc2(__a);
4337	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4338	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
4339	_CntrlBlk(__a, __a0);
4340	shared_ptr<_Tp> __r;
4341	__r.__ptr_ = __hold2.get()->get();
4342	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
4343	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4344	return __r;
4345	}
4346
4347	template<class _Tp>
4348	template<class _Alloc, class _A0, class _A1>
4349	shared_ptr<_Tp>
4350	shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1)
4351	{
4352	static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in allocate_shared" );
4353	typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
4354	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
4355	typedef __allocator_destructor<_Alloc2> _D2;
4356	_Alloc2 __alloc2(__a);
4357	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4358	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
4359	_CntrlBlk(__a, __a0, __a1);
4360	shared_ptr<_Tp> __r;
4361	__r.__ptr_ = __hold2.get()->get();
4362	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
4363	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4364	return __r;
4365	}
4366
4367	template<class _Tp>
4368	template<class _Alloc, class _A0, class _A1, class _A2>
4369	shared_ptr<_Tp>
4370	shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2)
4371	{
4372	static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in allocate_shared" );
4373	typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
4374	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
4375	typedef __allocator_destructor<_Alloc2> _D2;
4376	_Alloc2 __alloc2(__a);
4377	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
4378	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
4379	_CntrlBlk(__a, __a0, __a1, __a2);
4380	shared_ptr<_Tp> __r;
4381	__r.__ptr_ = __hold2.get()->get();
4382	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
4383	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
4384	return __r;
4385	}
4386
4387	#endif // _LIBCPP_HAS_NO_VARIADICS
4388
4389	template<class _Tp>	4203	template<class _Tp>
4390	shared_ptr<_Tp>::~shared_ptr()	4204	shared_ptr<_Tp>::~shared_ptr()
4391	{	4205	{
...	@@ -4567,8 +4381,6 @@ shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)	...	@@ -4567,8 +4381,6 @@ shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
4567	shared_ptr(__p, __d, __a).swap(*this);	4381	shared_ptr(__p, __d, __a).swap(*this);
4568	}	4382	}
4569		4383
4570	#ifndef _LIBCPP_HAS_NO_VARIADICS
4571
4572	template<class _Tp, class ..._Args>	4384	template<class _Tp, class ..._Args>
4573	inline _LIBCPP_INLINE_VISIBILITY	4385	inline _LIBCPP_INLINE_VISIBILITY
4574	typename enable_if	4386	typename enable_if
...	@@ -4578,7 +4390,17 @@ typename enable_if	...	@@ -4578,7 +4390,17 @@ typename enable_if
4578	>::type	4390	>::type
4579	make_shared(_Args&& ...__args)	4391	make_shared(_Args&& ...__args)
4580	{	4392	{
4581	return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...);	4393	static_assert(is_constructible<_Tp, _Args...>::value, "Can't construct object in make_shared");
		4394	typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
		4395	typedef allocator<_CntrlBlk> _A2;
		4396	typedef __allocator_destructor<_A2> _D2;
		4397
		4398	_A2 __a2;
		4399	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
		4400	::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...);
		4401
		4402	_Tp *__ptr = __hold2.get()->get();
		4403	return shared_ptr<_Tp>::__create_with_control_block(__ptr, __hold2.release());
4582	}	4404	}
4583		4405
4584	template<class _Tp, class _Alloc, class ..._Args>	4406	template<class _Tp, class _Alloc, class ..._Args>
...	@@ -4593,74 +4415,6 @@ allocate_shared(const _Alloc& __a, _Args&& ...__args)	...	@@ -4593,74 +4415,6 @@ allocate_shared(const _Alloc& __a, _Args&& ...__args)
4593	return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...);	4415	return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...);
4594	}	4416	}
4595		4417
4596	#else // _LIBCPP_HAS_NO_VARIADICS
4597
4598	template<class _Tp>
4599	inline _LIBCPP_INLINE_VISIBILITY
4600	shared_ptr<_Tp>
4601	make_shared()
4602	{
4603	return shared_ptr<_Tp>::make_shared();
4604	}
4605
4606	template<class _Tp, class _A0>
4607	inline _LIBCPP_INLINE_VISIBILITY
4608	shared_ptr<_Tp>
4609	make_shared(_A0& __a0)
4610	{
4611	return shared_ptr<_Tp>::make_shared(__a0);
4612	}
4613
4614	template<class _Tp, class _A0, class _A1>
4615	inline _LIBCPP_INLINE_VISIBILITY
4616	shared_ptr<_Tp>
4617	make_shared(_A0& __a0, _A1& __a1)
4618	{
4619	return shared_ptr<_Tp>::make_shared(__a0, __a1);
4620	}
4621
4622	template<class _Tp, class _A0, class _A1, class _A2>
4623	inline _LIBCPP_INLINE_VISIBILITY
4624	shared_ptr<_Tp>
4625	make_shared(_A0& __a0, _A1& __a1, _A2& __a2)
4626	{
4627	return shared_ptr<_Tp>::make_shared(__a0, __a1, __a2);
4628	}
4629
4630	template<class _Tp, class _Alloc>
4631	inline _LIBCPP_INLINE_VISIBILITY
4632	shared_ptr<_Tp>
4633	allocate_shared(const _Alloc& __a)
4634	{
4635	return shared_ptr<_Tp>::allocate_shared(__a);
4636	}
4637
4638	template<class _Tp, class _Alloc, class _A0>
4639	inline _LIBCPP_INLINE_VISIBILITY
4640	shared_ptr<_Tp>
4641	allocate_shared(const _Alloc& __a, _A0& __a0)
4642	{
4643	return shared_ptr<_Tp>::allocate_shared(__a, __a0);
4644	}
4645
4646	template<class _Tp, class _Alloc, class _A0, class _A1>
4647	inline _LIBCPP_INLINE_VISIBILITY
4648	shared_ptr<_Tp>
4649	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1)
4650	{
4651	return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1);
4652	}
4653
4654	template<class _Tp, class _Alloc, class _A0, class _A1, class _A2>
4655	inline _LIBCPP_INLINE_VISIBILITY
4656	shared_ptr<_Tp>
4657	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2)
4658	{
4659	return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1, __a2);
4660	}
4661
4662	#endif // _LIBCPP_HAS_NO_VARIADICS
4663
4664	template<class _Tp, class _Up>	4418	template<class _Tp, class _Up>
4665	inline _LIBCPP_INLINE_VISIBILITY	4419	inline _LIBCPP_INLINE_VISIBILITY
4666	bool	4420	bool
...	@@ -5590,4 +5344,8 @@ _LIBCPP_END_NAMESPACE_STD	...	@@ -5590,4 +5344,8 @@ _LIBCPP_END_NAMESPACE_STD
5590		5344
5591	_LIBCPP_POP_MACROS	5345	_LIBCPP_POP_MACROS
5592		5346
		5347	#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
		5348	# include <__pstl_memory>
		5349	#endif
		5350
5593	#endif // _LIBCPP_MEMORY	5351	#endif // _LIBCPP_MEMORY

lib/libcxx/include/module.modulemap+4

 @@ -275,6 +275,10 @@ module std [system] {
     header "exception"
     export *
   }
+  module execution {
+    header "execution"
+    export *
+  }
   module filesystem {
     header "filesystem"
     export *

lib/libcxx/include/mutex+4-4

...	@@ -86,9 +86,9 @@ public:	...	@@ -86,9 +86,9 @@ public:
86	void unlock();	86	void unlock();
87	};	87	};
88		88
89	struct defer_lock_t {};	89	struct defer_lock_t { explicit defer_lock_t() = default; };
90	struct try_to_lock_t {};	90	struct try_to_lock_t { explicit try_to_lock_t() = default; };
91	struct adopt_lock_t {};	91	struct adopt_lock_t { explicit adopt_lock_t() = default; };
92		92
93	inline constexpr defer_lock_t defer_lock{};	93	inline constexpr defer_lock_t defer_lock{};
94	inline constexpr try_to_lock_t try_to_lock{};	94	inline constexpr try_to_lock_t try_to_lock{};
...	@@ -650,7 +650,7 @@ public:	...	@@ -650,7 +650,7 @@ public:
650	#endif	650	#endif
651		651
652	template <class _Fp>	652	template <class _Fp>
653	void	653	void _LIBCPP_INLINE_VISIBILITY
654	__call_once_proxy(void* __vp)	654	__call_once_proxy(void* __vp)
655	{	655	{
656	__call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);	656	__call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);

lib/libcxx/include/new+2-2

...	@@ -39,7 +39,7 @@ struct destroying_delete_t { // C++20	...	@@ -39,7 +39,7 @@ struct destroying_delete_t { // C++20
39	};	39	};
40	inline constexpr destroying_delete_t destroying_delete{}; // C++20	40	inline constexpr destroying_delete_t destroying_delete{}; // C++20
41		41
42	struct nothrow_t {};	42	struct nothrow_t { explicit nothrow_t() = default; };
43	extern const nothrow_t nothrow;	43	extern const nothrow_t nothrow;
44	typedef void (*new_handler)();	44	typedef void (*new_handler)();
45	new_handler set_new_handler(new_handler new_p) noexcept;	45	new_handler set_new_handler(new_handler new_p) noexcept;
...	@@ -126,7 +126,7 @@ namespace std // purposefully not using versioning namespace	...	@@ -126,7 +126,7 @@ namespace std // purposefully not using versioning namespace
126	{	126	{
127		127
128	#if !defined(_LIBCPP_ABI_VCRUNTIME)	128	#if !defined(_LIBCPP_ABI_VCRUNTIME)
129	struct _LIBCPP_TYPE_VIS nothrow_t {};	129	struct _LIBCPP_TYPE_VIS nothrow_t { explicit nothrow_t() = default; };
130	extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;	130	extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
131		131
132	class _LIBCPP_EXCEPTION_ABI bad_alloc	132	class _LIBCPP_EXCEPTION_ABI bad_alloc

lib/libcxx/include/numeric+12-11

...	@@ -532,17 +532,14 @@ midpoint(_Tp __a, _Tp __b) noexcept	...	@@ -532,17 +532,14 @@ midpoint(_Tp __a, _Tp __b) noexcept
532	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK	532	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
533	{	533	{
534	using _Up = std::make_unsigned_t<_Tp>;	534	using _Up = std::make_unsigned_t<_Tp>;
		535	constexpr _Up __bitshift = std::numeric_limits<_Up>::digits - 1;
535		536
536	int __sign = 1;	537	_Up __diff = _Up(__b) - _Up(__a);
537	_Up __m = __a;	538	_Up __sign_bit = __b < __a;
538	_Up __M = __b;	539
539	if (__a > __b)	540	_Up __half_diff = (__diff / 2) + (__sign_bit << __bitshift) + (__sign_bit & __diff);
540	{	541
541	__sign = -1;	542	return __a + __half_diff;
542	__m = __b;
543	__M = __a;
544	}
545	return __a + __sign * _Tp(_Up(__M-__m) >> 1);
546	}	543	}
547		544
548		545
...	@@ -576,7 +573,7 @@ midpoint(_Fp __a, _Fp __b) noexcept	...	@@ -576,7 +573,7 @@ midpoint(_Fp __a, _Fp __b) noexcept
576	return __fp_abs(__a) <= __hi && __fp_abs(__b) <= __hi ? // typical case: overflow is impossible	573	return __fp_abs(__a) <= __hi && __fp_abs(__b) <= __hi ? // typical case: overflow is impossible
577	(__a + __b)/2 : // always correctly rounded	574	(__a + __b)/2 : // always correctly rounded
578	__fp_abs(__a) < __lo ? __a + __b/2 : // not safe to halve a	575	__fp_abs(__a) < __lo ? __a + __b/2 : // not safe to halve a
579	__fp_abs(__a) < __lo ? __a/2 + __b : // not safe to halve b	576	__fp_abs(__b) < __lo ? __a/2 + __b : // not safe to halve b
580	__a/2 + __b/2; // otherwise correctly rounded	577	__a/2 + __b/2; // otherwise correctly rounded
581	}	578	}
582		579
...	@@ -586,4 +583,8 @@ _LIBCPP_END_NAMESPACE_STD	...	@@ -586,4 +583,8 @@ _LIBCPP_END_NAMESPACE_STD
586		583
587	_LIBCPP_POP_MACROS	584	_LIBCPP_POP_MACROS
588		585
		586	#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
		587	# include <__pstl_numeric>
		588	#endif
		589
589	#endif // _LIBCPP_NUMERIC	590	#endif // _LIBCPP_NUMERIC

lib/libcxx/include/ostream+1-1

...	@@ -1055,7 +1055,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,	...	@@ -1055,7 +1055,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
1055	template<class _CharT, class _Traits>	1055	template<class _CharT, class _Traits>
1056	basic_ostream<_CharT, _Traits>&	1056	basic_ostream<_CharT, _Traits>&
1057	operator<<(basic_ostream<_CharT, _Traits>& __os,	1057	operator<<(basic_ostream<_CharT, _Traits>& __os,
1058	const basic_string_view<_CharT, _Traits> __sv)	1058	basic_string_view<_CharT, _Traits> __sv)
1059	{	1059	{
1060	return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size());	1060	return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size());
1061	}	1061	}

lib/libcxx/include/queue+1-1

...	@@ -562,7 +562,7 @@ priority_queue(_Compare, _Container)	...	@@ -562,7 +562,7 @@ priority_queue(_Compare, _Container)
562	template<class _InputIterator,	562	template<class _InputIterator,
563	class _Compare = less<typename iterator_traits<_InputIterator>::value_type>,	563	class _Compare = less<typename iterator_traits<_InputIterator>::value_type>,
564	class _Container = vector<typename iterator_traits<_InputIterator>::value_type>,	564	class _Container = vector<typename iterator_traits<_InputIterator>::value_type>,
565	class = typename enable_if< __is_input_iterator<_InputIterator>::value, nullptr_t>::type,	565	class = typename enable_if< __is_cpp17_input_iterator<_InputIterator>::value, nullptr_t>::type,
566	class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,	566	class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,
567	class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type	567	class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
568	>	568	>

lib/libcxx/include/random+27-22

 @@ -3645,7 +3645,7 @@ generate_canonical(_URNG& __g)
     const size_t __logR = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
 #endif
     const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0);
-    const _RealType _Rp = _URNG::max() - _URNG::min() + _RealType(1);
+    const _RealType _Rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1);
     _RealType __base = _Rp;
     _RealType _Sp = __g() - _URNG::min();
     for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp)
 @@ -4592,7 +4592,10 @@ public:
 template<class _IntType>
 poisson_distribution<_IntType>::param_type::param_type(double __mean)
-    : __mean_(__mean)
+    // According to the standard `inf` is a valid input, but it causes the
+    // distribution to hang, so we replace it with the maximum representable
+    // mean.
+    : __mean_(isinf(__mean) ? numeric_limits<double>::max() : __mean)
 {
     if (__mean_ < 10)
     {
 @@ -4610,7 +4613,7 @@ poisson_distribution<_IntType>::param_type::param_type(double __mean)
     {
         __s_ = _VSTD::sqrt(__mean_);
         __d_ = 6 * __mean_ * __mean_;
-        __l_ = static_cast<result_type>(__mean_ - 1.1484);
+        __l_ = std::trunc(__mean_ - 1.1484);
         __omega_ = .3989423 / __s_;
         double __b1_ = .4166667E-1 / __mean_;
         double __b2_ = .3 * __b1_ * __b1_;
 @@ -4627,12 +4630,12 @@ template<class _URNG>
 _IntType
 poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
 {
-    result_type __x;
+    double __tx;
     uniform_real_distribution<double> __urd;
     if (__pr.__mean_ < 10)
     {
-         __x = 0;
+         __tx = 0;
-        for (double __p = __urd(__urng); __p > __pr.__l_; ++__x)
+        for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx)
             __p *= __urd(__urng);
     }
     else
 @@ -4642,19 +4645,19 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
         double __u;
         if (__g > 0)
         {
-            __x = static_cast<result_type>(__g);
+            __tx = std::trunc(__g);
-            if (__x >= __pr.__l_)
+            if (__tx >= __pr.__l_)
-                return __x;
+                return std::__clamp_to_integral<result_type>(__tx);
-            __difmuk = __pr.__mean_ - __x;
+            __difmuk = __pr.__mean_ - __tx;
             __u = __urd(__urng);
             if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
-                return __x;
+                return std::__clamp_to_integral<result_type>(__tx);
         }
         exponential_distribution<double> __edist;
         for (bool __using_exp_dist = false; true; __using_exp_dist = true)
         {
             double __e;
-            if (__using_exp_dist || __g < 0)
+            if (__using_exp_dist || __g <= 0)
             {
                 double __t;
                 do
 @@ -4664,31 +4667,31 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
                     __u += __u - 1;
                     __t = 1.8 + (__u < 0 ? -__e : __e);
                 } while (__t <= -.6744);
-                __x = __pr.__mean_ + __pr.__s_ * __t;
+                __tx = std::trunc(__pr.__mean_ + __pr.__s_ * __t);
-                __difmuk = __pr.__mean_ - __x;
+                __difmuk = __pr.__mean_ - __tx;
                 __using_exp_dist = true;
             }
             double __px;
             double __py;
-            if (__x < 10)
+            if (__tx < 10 && __tx >= 0)
             {
                 const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
                                              40320, 362880};
                 __px = -__pr.__mean_;
-                __py = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x];
+                __py = _VSTD::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)];
             }
             else
             {
-                double __del = .8333333E-1 / __x;
+                double __del = .8333333E-1 / __tx;
                 __del -= 4.8 * __del * __del * __del;
-                double __v = __difmuk / __x;
+                double __v = __difmuk / __tx;
                 if (_VSTD::abs(__v) > 0.25)
-                    __px = __x * _VSTD::log(1 + __v) - __difmuk - __del;
+                    __px = __tx * _VSTD::log(1 + __v) - __difmuk - __del;
                 else
-                    __px = __x * __v * __v * (((((((.1250060 * __v + -.1384794) *
+                    __px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) *
                            __v + .1421878) * __v + -.1661269) * __v + .2000118) *
                            __v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
-                __py = .3989423 / _VSTD::sqrt(__x);
+                __py = .3989423 / _VSTD::sqrt(__tx);
             }
             double __r = (0.5 - __difmuk) / __pr.__s_;
             double __r2 = __r * __r;
 @@ -4708,7 +4711,7 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
             }
         }
     }
-    return __x;
+    return std::__clamp_to_integral<result_type>(__tx);
 }
 template <class _CharT, class _Traits, class _IntType>
 @@ -6102,6 +6105,7 @@ public:
         template<class _UnaryOperation>
             param_type(size_t __nw, result_type __xmin, result_type __xmax,
                        _UnaryOperation __fw);
+        param_type(param_type const&) = default;
         param_type & operator=(const param_type& __rhs);
         _LIBCPP_INLINE_VISIBILITY
 @@ -6425,6 +6429,7 @@ public:
         template<class _UnaryOperation>
             param_type(size_t __nw, result_type __xmin, result_type __xmax,
                        _UnaryOperation __fw);
+        param_type(param_type const&) = default;
         param_type & operator=(const param_type& __rhs);
         _LIBCPP_INLINE_VISIBILITY

lib/libcxx/include/regex+31-21

 @@ -169,15 +169,15 @@ public:
     // assign:
     basic_regex& assign(const basic_regex& that);
     basic_regex& assign(basic_regex&& that) noexcept;
-    basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
+    basic_regex& assign(const charT* ptr,           flag_type f = regex_constants::ECMAScript);
-    basic_regex& assign(const charT* p, size_t len, flag_type f);
+    basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
     template <class string_traits, class A>
         basic_regex& assign(const basic_string<charT, string_traits, A>& s,
-                            flag_type f = regex_constants::ECMAScript);
+                                                    flag_type f = regex_constants::ECMAScript);
     template <class InputIterator>
         basic_regex& assign(InputIterator first, InputIterator last,
-                            flag_type f = regex_constants::ECMAScript);
+                                                    flag_type f = regex_constants::ECMAScript);
-    basic_regex& assign(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
+    basic_regex& assign(initializer_list<charT>,    flag_type f = regex_constants::ECMAScript);
     // const operations:
     unsigned mark_count() const;
 @@ -965,7 +965,8 @@ enum error_type
     error_stack,
     __re_err_grammar,
     __re_err_empty,
-    __re_err_unknown
+    __re_err_unknown,
+    __re_err_parse
 };
 }  // regex_constants
 @@ -2539,8 +2540,7 @@ public:
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
+        __init(__p, __p + __traits_.length(__p));
-        __parse(__p, __p + __traits_.length(__p));
         }
     _LIBCPP_INLINE_VISIBILITY
 @@ -2548,8 +2548,7 @@ public:
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
+        __init(__p, __p + __len);
-        __parse(__p, __p + __len);
         }
 //     basic_regex(const basic_regex&) = default;
 @@ -2561,8 +2560,7 @@ public:
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
+        __init(__p.begin(), __p.end());
-        __parse(__p.begin(), __p.end());
         }
     template <class _ForwardIterator>
 @@ -2572,8 +2570,7 @@ public:
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
+        __init(__first, __last);
-        __parse(__first, __last);
         }
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
 @@ -2582,8 +2579,7 @@ public:
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
-        if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
+        __init(__il.begin(), __il.end());
-        __parse(__il.begin(), __il.end());
         }
 #endif  // _LIBCPP_CXX03_LANG
 @@ -2617,7 +2613,7 @@ public:
     basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
         {return assign(__p, __p + __traits_.length(__p), __f);}
     _LIBCPP_INLINE_VISIBILITY
-    basic_regex& assign(const value_type* __p, size_t __len, flag_type __f)
+    basic_regex& assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
         {return assign(__p, __p + __len, __f);}
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
 @@ -2629,8 +2625,8 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-             __is_input_iterator  <_InputIterator>::value &&
+             __is_cpp17_input_iterator  <_InputIterator>::value &&
-            !__is_forward_iterator<_InputIterator>::value,
+            !__is_cpp17_forward_iterator<_InputIterator>::value,
             basic_regex&
         >::type
         assign(_InputIterator __first, _InputIterator __last,
 @@ -2656,7 +2652,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value,
+            __is_cpp17_forward_iterator<_ForwardIterator>::value,
             basic_regex&
         >::type
         assign(_ForwardIterator __first, _ForwardIterator __last,
 @@ -2698,6 +2694,9 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     unsigned __loop_count() const {return __loop_count_;}
+    template <class _ForwardIterator>
+        void
+        __init(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse(_ForwardIterator __first, _ForwardIterator __last);
 @@ -2953,7 +2952,7 @@ private:
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template <class _ForwardIterator,
-          class = typename enable_if<__is_forward_iterator<_ForwardIterator>::value, nullptr_t>::type
+          class = typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value, nullptr_t>::type
 >
 basic_regex(_ForwardIterator, _ForwardIterator,
             regex_constants::syntax_option_type = regex_constants::ECMAScript)
 @@ -3054,6 +3053,17 @@ __lookahead<_CharT, _Traits>::__exec(__state& __s) const
     }
 }
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+void
+basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last)
+{
+    if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
+    _ForwardIterator __temp = __parse(__first, __last);
+    if ( __temp != __last)
+        __throw_regex_error<regex_constants::__re_err_parse>();
+}
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator

lib/libcxx/include/set+12-12

lib/libcxx/include/span+36-36

...	@@ -39,7 +39,7 @@ public:	...	@@ -39,7 +39,7 @@ public:
39	// constants and types	39	// constants and types
40	using element_type = ElementType;	40	using element_type = ElementType;
41	using value_type = remove_cv_t<ElementType>;	41	using value_type = remove_cv_t<ElementType>;
42	using index_type = size_t;	42	using size_type = size_t;
43	using difference_type = ptrdiff_t;	43	using difference_type = ptrdiff_t;
44	using pointer = element_type*;	44	using pointer = element_type*;
45	using const_pointer = const element_type*;	45	using const_pointer = const element_type*;
...	@@ -49,11 +49,11 @@ public:	...	@@ -49,11 +49,11 @@ public:
49	using const_iterator = implementation-defined;	49	using const_iterator = implementation-defined;
50	using reverse_iterator = std::reverse_iterator<iterator>;	50	using reverse_iterator = std::reverse_iterator<iterator>;
51	using const_reverse_iterator = std::reverse_iterator<const_iterator>;	51	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
52	static constexpr index_type extent = Extent;	52	static constexpr size_type extent = Extent;
53		53
54	// [span.cons], span constructors, copy, assignment, and destructor	54	// [span.cons], span constructors, copy, assignment, and destructor
55	constexpr span() noexcept;	55	constexpr span() noexcept;
56	constexpr span(pointer ptr, index_type count);	56	constexpr span(pointer ptr, size_type count);
57	constexpr span(pointer firstElem, pointer lastElem);	57	constexpr span(pointer firstElem, pointer lastElem);
58	template <size_t N>	58	template <size_t N>
59	constexpr span(element_type (&arr)[N]) noexcept;	59	constexpr span(element_type (&arr)[N]) noexcept;
...	@@ -79,17 +79,17 @@ public:	...	@@ -79,17 +79,17 @@ public:
79	template <size_t Offset, size_t Count = dynamic_extent>	79	template <size_t Offset, size_t Count = dynamic_extent>
80	constexpr span<element_type, see below> subspan() const;	80	constexpr span<element_type, see below> subspan() const;
81		81
82	constexpr span<element_type, dynamic_extent> first(index_type count) const;	82	constexpr span<element_type, dynamic_extent> first(size_type count) const;
83	constexpr span<element_type, dynamic_extent> last(index_type count) const;	83	constexpr span<element_type, dynamic_extent> last(size_type count) const;
84	constexpr span<element_type, dynamic_extent> subspan(index_type offset, index_type count = dynamic_extent) const;	84	constexpr span<element_type, dynamic_extent> subspan(size_type offset, size_type count = dynamic_extent) const;
85		85
86	// [span.obs], span observers	86	// [span.obs], span observers
87	constexpr index_type size() const noexcept;	87	constexpr size_type size() const noexcept;
88	constexpr index_type size_bytes() const noexcept;	88	constexpr size_type size_bytes() const noexcept;
89	constexpr bool empty() const noexcept;	89	constexpr bool empty() const noexcept;
90		90
91	// [span.elem], span element access	91	// [span.elem], span element access
92	constexpr reference operator[](index_type idx) const;	92	constexpr reference operator[](size_type idx) const;
93	constexpr reference front() const;	93	constexpr reference front() const;
94	constexpr reference back() const;	94	constexpr reference back() const;
95	constexpr pointer data() const noexcept;	95	constexpr pointer data() const noexcept;
...	@@ -105,8 +105,8 @@ public:	...	@@ -105,8 +105,8 @@ public:
105	constexpr const_reverse_iterator crend() const noexcept;	105	constexpr const_reverse_iterator crend() const noexcept;
106		106
107	private:	107	private:
108	pointer data_; // exposition only	108	pointer data_; // exposition only
109	index_type size_; // exposition only	109	size_type size_; // exposition only
110	};	110	};
111		111
112	template<class T, size_t N>	112	template<class T, size_t N>
...	@@ -195,7 +195,7 @@ public:	...	@@ -195,7 +195,7 @@ public:
195	// constants and types	195	// constants and types
196	using element_type = _Tp;	196	using element_type = _Tp;
197	using value_type = remove_cv_t<_Tp>;	197	using value_type = remove_cv_t<_Tp>;
198	using index_type = size_t;	198	using size_type = size_t;
199	using difference_type = ptrdiff_t;	199	using difference_type = ptrdiff_t;
200	using pointer = _Tp *;	200	using pointer = _Tp *;
201	using const_pointer = const _Tp *;	201	using const_pointer = const _Tp *;
...	@@ -206,7 +206,7 @@ public:	...	@@ -206,7 +206,7 @@ public:
206	using reverse_iterator = _VSTD::reverse_iterator<iterator>;	206	using reverse_iterator = _VSTD::reverse_iterator<iterator>;
207	using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;	207	using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
208		208
209	static constexpr index_type extent = _Extent;	209	static constexpr size_type extent = _Extent;
210		210
211	// [span.cons], span constructors, copy, assignment, and destructor	211	// [span.cons], span constructors, copy, assignment, and destructor
212	_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}	212	_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}
...	@@ -215,7 +215,7 @@ public:	...	@@ -215,7 +215,7 @@ public:
215	constexpr span (const span&) noexcept = default;	215	constexpr span (const span&) noexcept = default;
216	constexpr span& operator=(const span&) noexcept = default;	216	constexpr span& operator=(const span&) noexcept = default;
217		217
218	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, index_type __count) : __data{__ptr}	218	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, size_type __count) : __data{__ptr}
219	{ (void)__count; _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (ptr, len)"); }	219	{ (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}	220	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}
221	{ (void)__l; _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }	221	{ (void)__l; _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }
...	@@ -260,14 +260,14 @@ public:	...	@@ -260,14 +260,14 @@ public:
260	}	260	}
261		261
262	_LIBCPP_INLINE_VISIBILITY	262	_LIBCPP_INLINE_VISIBILITY
263	constexpr span<element_type, dynamic_extent> first(index_type __count) const noexcept	263	constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept
264	{	264	{
265	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::first(count)");	265	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::first(count)");
266	return {data(), __count};	266	return {data(), __count};
267	}	267	}
268		268
269	_LIBCPP_INLINE_VISIBILITY	269	_LIBCPP_INLINE_VISIBILITY
270	constexpr span<element_type, dynamic_extent> last(index_type __count) const noexcept	270	constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept
271	{	271	{
272	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::last(count)");	272	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::last(count)");
273	return {data() + size() - __count, __count};	273	return {data() + size() - __count, __count};
...	@@ -285,7 +285,7 @@ public:	...	@@ -285,7 +285,7 @@ public:
285		285
286	_LIBCPP_INLINE_VISIBILITY	286	_LIBCPP_INLINE_VISIBILITY
287	constexpr span<element_type, dynamic_extent>	287	constexpr span<element_type, dynamic_extent>
288	subspan(index_type __offset, index_type __count = dynamic_extent) const noexcept	288	subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
289	{	289	{
290	_LIBCPP_ASSERT(__offset <= size(), "Offset out of range in span::subspan(offset, count)");	290	_LIBCPP_ASSERT(__offset <= size(), "Offset out of range in span::subspan(offset, count)");
291	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "Count out of range in span::subspan(offset, count)");	291	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "Count out of range in span::subspan(offset, count)");
...	@@ -295,11 +295,11 @@ public:	...	@@ -295,11 +295,11 @@ public:
295	return {data() + __offset, __count};	295	return {data() + __offset, __count};
296	}	296	}
297		297
298	_LIBCPP_INLINE_VISIBILITY constexpr index_type size() const noexcept { return _Extent; }	298	_LIBCPP_INLINE_VISIBILITY constexpr size_type size() const noexcept { return _Extent; }
299	_LIBCPP_INLINE_VISIBILITY constexpr index_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }	299	_LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
300	_LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return _Extent == 0; }	300	_LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return _Extent == 0; }
301		301
302	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](index_type __idx) const noexcept	302	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
303	{	303	{
304	_LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T,N>[] index out of bounds");	304	_LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T,N>[] index out of bounds");
305	return __data[__idx];	305	return __data[__idx];
...	@@ -356,7 +356,7 @@ public:	...	@@ -356,7 +356,7 @@ public:
356	// constants and types	356	// constants and types
357	using element_type = _Tp;	357	using element_type = _Tp;
358	using value_type = remove_cv_t<_Tp>;	358	using value_type = remove_cv_t<_Tp>;
359	using index_type = size_t;	359	using size_type = size_t;
360	using difference_type = ptrdiff_t;	360	using difference_type = ptrdiff_t;
361	using pointer = _Tp *;	361	using pointer = _Tp *;
362	using const_pointer = const _Tp *;	362	using const_pointer = const _Tp *;
...	@@ -367,7 +367,7 @@ public:	...	@@ -367,7 +367,7 @@ public:
367	using reverse_iterator = _VSTD::reverse_iterator<iterator>;	367	using reverse_iterator = _VSTD::reverse_iterator<iterator>;
368	using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;	368	using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
369		369
370	static constexpr index_type extent = dynamic_extent;	370	static constexpr size_type extent = dynamic_extent;
371		371
372	// [span.cons], span constructors, copy, assignment, and destructor	372	// [span.cons], span constructors, copy, assignment, and destructor
373	_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {}	373	_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {}
...	@@ -375,7 +375,7 @@ public:	...	@@ -375,7 +375,7 @@ public:
375	constexpr span (const span&) noexcept = default;	375	constexpr span (const span&) noexcept = default;
376	constexpr span& operator=(const span&) noexcept = default;	376	constexpr span& operator=(const span&) noexcept = default;
377		377
378	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, index_type __count) : __data{__ptr}, __size{__count} {}	378	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, size_type __count) : __data{__ptr}, __size{__count} {}
379	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}, __size{static_cast<size_t>(distance(__f, __l))} {}	379	_LIBCPP_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}, __size{static_cast<size_t>(distance(__f, __l))} {}
380		380
381	template <size_t _Sz>	381	template <size_t _Sz>
...	@@ -394,13 +394,13 @@ public:	...	@@ -394,13 +394,13 @@ public:
394	_LIBCPP_INLINE_VISIBILITY	394	_LIBCPP_INLINE_VISIBILITY
395	constexpr span( _Container& __c,	395	constexpr span( _Container& __c,
396	enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr)	396	enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr)
397	: __data{_VSTD::data(__c)}, __size{(index_type) _VSTD::size(__c)} {}	397	: __data{_VSTD::data(__c)}, __size{(size_type) _VSTD::size(__c)} {}
398		398
399	template <class _Container>	399	template <class _Container>
400	_LIBCPP_INLINE_VISIBILITY	400	_LIBCPP_INLINE_VISIBILITY
401	constexpr span(const _Container& __c,	401	constexpr span(const _Container& __c,
402	enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, nullptr_t> = nullptr)	402	enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, nullptr_t> = nullptr)
403	: __data{_VSTD::data(__c)}, __size{(index_type) _VSTD::size(__c)} {}	403	: __data{_VSTD::data(__c)}, __size{(size_type) _VSTD::size(__c)} {}
404		404
405		405
406	template <class _OtherElementType, size_t _OtherExtent>	406	template <class _OtherElementType, size_t _OtherExtent>
...	@@ -430,14 +430,14 @@ public:	...	@@ -430,14 +430,14 @@ public:
430	}	430	}
431		431
432	_LIBCPP_INLINE_VISIBILITY	432	_LIBCPP_INLINE_VISIBILITY
433	constexpr span<element_type, dynamic_extent> first(index_type __count) const noexcept	433	constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept
434	{	434	{
435	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::first(count)");	435	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::first(count)");
436	return {data(), __count};	436	return {data(), __count};
437	}	437	}
438		438
439	_LIBCPP_INLINE_VISIBILITY	439	_LIBCPP_INLINE_VISIBILITY
440	constexpr span<element_type, dynamic_extent> last (index_type __count) const noexcept	440	constexpr span<element_type, dynamic_extent> last (size_type __count) const noexcept
441	{	441	{
442	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::last(count)");	442	_LIBCPP_ASSERT(__count <= size(), "Count out of range in span::last(count)");
443	return {data() + size() - __count, __count};	443	return {data() + size() - __count, __count};
...	@@ -454,7 +454,7 @@ public:	...	@@ -454,7 +454,7 @@ public:
454		454
455	constexpr span<element_type, dynamic_extent>	455	constexpr span<element_type, dynamic_extent>
456	_LIBCPP_INLINE_VISIBILITY	456	_LIBCPP_INLINE_VISIBILITY
457	subspan(index_type __offset, index_type __count = dynamic_extent) const noexcept	457	subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
458	{	458	{
459	_LIBCPP_ASSERT(__offset <= size(), "Offset out of range in span::subspan(offset, count)");	459	_LIBCPP_ASSERT(__offset <= size(), "Offset out of range in span::subspan(offset, count)");
460	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "count out of range in span::subspan(offset, count)");	460	_LIBCPP_ASSERT(__count <= size() \|\| __count == dynamic_extent, "count out of range in span::subspan(offset, count)");
...	@@ -464,11 +464,11 @@ public:	...	@@ -464,11 +464,11 @@ public:
464	return {data() + __offset, __count};	464	return {data() + __offset, __count};
465	}	465	}
466		466
467	_LIBCPP_INLINE_VISIBILITY constexpr index_type size() const noexcept { return __size; }	467	_LIBCPP_INLINE_VISIBILITY constexpr size_type size() const noexcept { return __size; }
468	_LIBCPP_INLINE_VISIBILITY constexpr index_type size_bytes() const noexcept { return __size * sizeof(element_type); }	468	_LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return __size * sizeof(element_type); }
469	_LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return __size == 0; }	469	_LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return __size == 0; }
470		470
471	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](index_type __idx) const noexcept	471	_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
472	{	472	{
473	_LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T>[] index out of bounds");	473	_LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T>[] index out of bounds");
474	return __data[__idx];	474	return __data[__idx];
...	@@ -505,7 +505,7 @@ public:	...	@@ -505,7 +505,7 @@ public:
505	__data = __other.__data;	505	__data = __other.__data;
506	__other.__data = __p;	506	__other.__data = __p;
507		507
508	index_type __sz = __size;	508	size_type __sz = __size;
509	__size = __other.__size;	509	__size = __other.__size;
510	__other.__size = __sz;	510	__other.__size = __sz;
511	}	511	}
...	@@ -517,8 +517,8 @@ public:	...	@@ -517,8 +517,8 @@ public:
517	{ return {reinterpret_cast<byte *>(data()), size_bytes()}; }	517	{ return {reinterpret_cast<byte *>(data()), size_bytes()}; }
518		518
519	private:	519	private:
520	pointer __data;	520	pointer __data;
521	index_type __size;	521	size_type __size;
522	};	522	};
523		523
524	// tuple interface	524	// tuple interface

lib/libcxx/include/string+96-90

...	@@ -625,7 +625,7 @@ struct __libcpp_string_gets_noexcept_iterator_impl : public true_type {};	...	@@ -625,7 +625,7 @@ struct __libcpp_string_gets_noexcept_iterator_impl : public true_type {};
625	template <class _Iter>	625	template <class _Iter>
626	struct __libcpp_string_gets_noexcept_iterator_impl : public false_type {};	626	struct __libcpp_string_gets_noexcept_iterator_impl : public false_type {};
627	#else	627	#else
628	template <class _Iter, bool = __is_forward_iterator<_Iter>::value>	628	template <class _Iter, bool = __is_cpp17_forward_iterator<_Iter>::value>
629	struct __libcpp_string_gets_noexcept_iterator_impl : public _LIBCPP_BOOL_CONSTANT((	629	struct __libcpp_string_gets_noexcept_iterator_impl : public _LIBCPP_BOOL_CONSTANT((
630	noexcept(++(declval<_Iter&>())) &&	630	noexcept(++(declval<_Iter&>())) &&
631	is_nothrow_assignable<_Iter&, _Iter>::value &&	631	is_nothrow_assignable<_Iter&, _Iter>::value &&
...	@@ -812,11 +812,9 @@ public:	...	@@ -812,11 +812,9 @@ public:
812	basic_string(basic_string&& __str, const allocator_type& __a);	812	basic_string(basic_string&& __str, const allocator_type& __a);
813	#endif // _LIBCPP_CXX03_LANG	813	#endif // _LIBCPP_CXX03_LANG
814		814
815	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
816	template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>	815	template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
817	#endif
818	_LIBCPP_INLINE_VISIBILITY	816	_LIBCPP_INLINE_VISIBILITY
819	basic_string(const _CharT* __s) {	817	basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
820	_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");	818	_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
821	__init(__s, traits_type::length(__s));	819	__init(__s, traits_type::length(__s));
822	# if _LIBCPP_DEBUG_LEVEL >= 2	820	# if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -824,9 +822,7 @@ public:	...	@@ -824,9 +822,7 @@ public:
824	# endif	822	# endif
825	}	823	}
826		824
827	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
828	template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>	825	template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
829	#endif
830	_LIBCPP_INLINE_VISIBILITY	826	_LIBCPP_INLINE_VISIBILITY
831	basic_string(const _CharT* __s, const _Allocator& __a);	827	basic_string(const _CharT* __s, const _Allocator& __a);
832		828
...	@@ -837,9 +833,7 @@ public:	...	@@ -837,9 +833,7 @@ public:
837	_LIBCPP_INLINE_VISIBILITY	833	_LIBCPP_INLINE_VISIBILITY
838	basic_string(size_type __n, _CharT __c);	834	basic_string(size_type __n, _CharT __c);
839		835
840	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
841	template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>	836	template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
842	#endif
843	_LIBCPP_INLINE_VISIBILITY	837	_LIBCPP_INLINE_VISIBILITY
844	basic_string(size_type __n, _CharT __c, const _Allocator& __a);	838	basic_string(size_type __n, _CharT __c, const _Allocator& __a);
845		839
...	@@ -862,10 +856,10 @@ public:	...	@@ -862,10 +856,10 @@ public:
862	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	856	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
863	explicit basic_string(const _Tp& __t, const allocator_type& __a);	857	explicit basic_string(const _Tp& __t, const allocator_type& __a);
864		858
865	template<class _InputIterator, class = typename enable_if<__is_input_iterator<_InputIterator>::value>::type>	859	template<class _InputIterator, class = typename enable_if<__is_cpp17_input_iterator<_InputIterator>::value>::type>
866	_LIBCPP_INLINE_VISIBILITY	860	_LIBCPP_INLINE_VISIBILITY
867	basic_string(_InputIterator __first, _InputIterator __last);	861	basic_string(_InputIterator __first, _InputIterator __last);
868	template<class _InputIterator, class = typename enable_if<__is_input_iterator<_InputIterator>::value>::type>	862	template<class _InputIterator, class = typename enable_if<__is_cpp17_input_iterator<_InputIterator>::value>::type>
869	_LIBCPP_INLINE_VISIBILITY	863	_LIBCPP_INLINE_VISIBILITY
870	basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);	864	basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
871	#ifndef _LIBCPP_CXX03_LANG	865	#ifndef _LIBCPP_CXX03_LANG
...	@@ -1029,7 +1023,7 @@ public:	...	@@ -1029,7 +1023,7 @@ public:
1029	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	1023	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1030	typename enable_if	1024	typename enable_if
1031	<	1025	<
1032	__is_exactly_input_iterator<_InputIterator>::value	1026	__is_exactly_cpp17_input_iterator<_InputIterator>::value
1033	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,	1027	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
1034	basic_string&	1028	basic_string&
1035	>::type	1029	>::type
...	@@ -1043,7 +1037,7 @@ public:	...	@@ -1043,7 +1037,7 @@ public:
1043	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	1037	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1044	typename enable_if	1038	typename enable_if
1045	<	1039	<
1046	__is_forward_iterator<_ForwardIterator>::value	1040	__is_cpp17_forward_iterator<_ForwardIterator>::value
1047	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,	1041	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
1048	basic_string&	1042	basic_string&
1049	>::type	1043	>::type
...	@@ -1097,7 +1091,7 @@ public:	...	@@ -1097,7 +1091,7 @@ public:
1097	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	1091	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1098	typename enable_if	1092	typename enable_if
1099	<	1093	<
1100	__is_exactly_input_iterator<_InputIterator>::value	1094	__is_exactly_cpp17_input_iterator<_InputIterator>::value
1101	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,	1095	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
1102	basic_string&	1096	basic_string&
1103	>::type	1097	>::type
...	@@ -1106,7 +1100,7 @@ public:	...	@@ -1106,7 +1100,7 @@ public:
1106	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	1100	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1107	typename enable_if	1101	typename enable_if
1108	<	1102	<
1109	__is_forward_iterator<_ForwardIterator>::value	1103	__is_cpp17_forward_iterator<_ForwardIterator>::value
1110	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,	1104	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
1111	basic_string&	1105	basic_string&
1112	>::type	1106	>::type
...	@@ -1148,7 +1142,7 @@ public:	...	@@ -1148,7 +1142,7 @@ public:
1148	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	1142	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1149	typename enable_if	1143	typename enable_if
1150	<	1144	<
1151	__is_exactly_input_iterator<_InputIterator>::value	1145	__is_exactly_cpp17_input_iterator<_InputIterator>::value
1152	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,	1146	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
1153	iterator	1147	iterator
1154	>::type	1148	>::type
...	@@ -1157,7 +1151,7 @@ public:	...	@@ -1157,7 +1151,7 @@ public:
1157	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	1151	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1158	typename enable_if	1152	typename enable_if
1159	<	1153	<
1160	__is_forward_iterator<_ForwardIterator>::value	1154	__is_cpp17_forward_iterator<_ForwardIterator>::value
1161	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,	1155	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
1162	iterator	1156	iterator
1163	>::type	1157	>::type
...	@@ -1219,7 +1213,7 @@ public:	...	@@ -1219,7 +1213,7 @@ public:
1219	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS	1213	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1220	typename enable_if	1214	typename enable_if
1221	<	1215	<
1222	__is_input_iterator<_InputIterator>::value,	1216	__is_cpp17_input_iterator<_InputIterator>::value,
1223	basic_string&	1217	basic_string&
1224	>::type	1218	>::type
1225	replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);	1219	replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
...	@@ -1245,10 +1239,10 @@ public:	...	@@ -1245,10 +1239,10 @@ public:
1245	_LIBCPP_INLINE_VISIBILITY	1239	_LIBCPP_INLINE_VISIBILITY
1246	const value_type* c_str() const _NOEXCEPT {return data();}	1240	const value_type* c_str() const _NOEXCEPT {return data();}
1247	_LIBCPP_INLINE_VISIBILITY	1241	_LIBCPP_INLINE_VISIBILITY
1248	const value_type* data() const _NOEXCEPT {return _VSTD::__to_raw_pointer(__get_pointer());}	1242	const value_type* data() const _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
1249	#if _LIBCPP_STD_VER > 14 \|\| defined(_LIBCPP_BUILDING_LIBRARY)	1243	#if _LIBCPP_STD_VER > 14 \|\| defined(_LIBCPP_BUILDING_LIBRARY)
1250	_LIBCPP_INLINE_VISIBILITY	1244	_LIBCPP_INLINE_VISIBILITY
1251	value_type* data() _NOEXCEPT {return _VSTD::__to_raw_pointer(__get_pointer());}	1245	value_type* data() _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
1252	#endif	1246	#endif
1253		1247
1254	_LIBCPP_INLINE_VISIBILITY	1248	_LIBCPP_INLINE_VISIBILITY
...	@@ -1553,7 +1547,7 @@ private:	...	@@ -1553,7 +1547,7 @@ private:
1553	inline	1547	inline
1554	typename enable_if	1548	typename enable_if
1555	<	1549	<
1556	__is_exactly_input_iterator<_InputIterator>::value,	1550	__is_exactly_cpp17_input_iterator<_InputIterator>::value,
1557	void	1551	void
1558	>::type	1552	>::type
1559	__init(_InputIterator __first, _InputIterator __last);	1553	__init(_InputIterator __first, _InputIterator __last);
...	@@ -1562,7 +1556,7 @@ private:	...	@@ -1562,7 +1556,7 @@ private:
1562	inline	1556	inline
1563	typename enable_if	1557	typename enable_if
1564	<	1558	<
1565	__is_forward_iterator<_ForwardIterator>::value,	1559	__is_cpp17_forward_iterator<_ForwardIterator>::value,
1566	void	1560	void
1567	>::type	1561	>::type
1568	__init(_ForwardIterator __first, _ForwardIterator __last);	1562	__init(_ForwardIterator __first, _ForwardIterator __last);
...	@@ -1658,7 +1652,7 @@ private:	...	@@ -1658,7 +1652,7 @@ private:
1658	template<class _InputIterator,	1652	template<class _InputIterator,
1659	class _CharT = typename iterator_traits<_InputIterator>::value_type,	1653	class _CharT = typename iterator_traits<_InputIterator>::value_type,
1660	class _Allocator = allocator<_CharT>,	1654	class _Allocator = allocator<_CharT>,
1661	class = typename enable_if<__is_input_iterator<_InputIterator>::value, void>::type,	1655	class = typename enable_if<__is_cpp17_input_iterator<_InputIterator>::value, void>::type,
1662	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type	1656	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type
1663	>	1657	>
1664	basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())	1658	basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
...	@@ -1727,6 +1721,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -1727,6 +1721,7 @@ template <class _CharT, class _Traits, class _Allocator>
1727	inline	1721	inline
1728	basic_string<_CharT, _Traits, _Allocator>::basic_string()	1722	basic_string<_CharT, _Traits, _Allocator>::basic_string()
1729	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)	1723	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
		1724	: __r_(__default_init_tag(), __default_init_tag())
1730	{	1725	{
1731	#if _LIBCPP_DEBUG_LEVEL >= 2	1726	#if _LIBCPP_DEBUG_LEVEL >= 2
1732	__get_db()->__insert_c(this);	1727	__get_db()->__insert_c(this);
...	@@ -1742,7 +1737,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __	...	@@ -1742,7 +1737,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __
1742	#else	1737	#else
1743	_NOEXCEPT	1738	_NOEXCEPT
1744	#endif	1739	#endif
1745	: __r_(__second_tag(), __a)	1740	: __r_(__default_init_tag(), __a)
1746	{	1741	{
1747	#if _LIBCPP_DEBUG_LEVEL >= 2	1742	#if _LIBCPP_DEBUG_LEVEL >= 2
1748	__get_db()->__insert_c(this);	1743	__get_db()->__insert_c(this);
...	@@ -1771,7 +1766,7 @@ void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,	...	@@ -1771,7 +1766,7 @@ void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
1771	__set_long_cap(__cap+1);	1766	__set_long_cap(__cap+1);
1772	__set_long_size(__sz);	1767	__set_long_size(__sz);
1773	}	1768	}
1774	traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);	1769	traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
1775	traits_type::assign(__p[__sz], value_type());	1770	traits_type::assign(__p[__sz], value_type());
1776	}	1771	}
1777		1772
...	@@ -1795,16 +1790,14 @@ basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_ty	...	@@ -1795,16 +1790,14 @@ basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_ty
1795	__set_long_cap(__cap+1);	1790	__set_long_cap(__cap+1);
1796	__set_long_size(__sz);	1791	__set_long_size(__sz);
1797	}	1792	}
1798	traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);	1793	traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
1799	traits_type::assign(__p[__sz], value_type());	1794	traits_type::assign(__p[__sz], value_type());
1800	}	1795	}
1801		1796
1802	template <class _CharT, class _Traits, class _Allocator>	1797	template <class _CharT, class _Traits, class _Allocator>
1803	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1804	template <class>	1798	template <class>
1805	#endif
1806	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)	1799	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
1807	: __r_(__second_tag(), __a)	1800	: __r_(__default_init_tag(), __a)
1808	{	1801	{
1809	_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");	1802	_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
1810	__init(__s, traits_type::length(__s));	1803	__init(__s, traits_type::length(__s));
...	@@ -1816,6 +1809,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const	...	@@ -1816,6 +1809,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const
1816	template <class _CharT, class _Traits, class _Allocator>	1809	template <class _CharT, class _Traits, class _Allocator>
1817	inline	1810	inline
1818	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)	1811	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
		1812	: __r_(__default_init_tag(), __default_init_tag())
1819	{	1813	{
1820	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n) detected nullptr");	1814	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n) detected nullptr");
1821	__init(__s, __n);	1815	__init(__s, __n);
...	@@ -1827,7 +1821,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_	...	@@ -1827,7 +1821,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_
1827	template <class _CharT, class _Traits, class _Allocator>	1821	template <class _CharT, class _Traits, class _Allocator>
1828	inline	1822	inline
1829	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)	1823	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
1830	: __r_(__second_tag(), __a)	1824	: __r_(__default_init_tag(), __a)
1831	{	1825	{
1832	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");	1826	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
1833	__init(__s, __n);	1827	__init(__s, __n);
...	@@ -1838,12 +1832,12 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_	...	@@ -1838,12 +1832,12 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_
1838		1832
1839	template <class _CharT, class _Traits, class _Allocator>	1833	template <class _CharT, class _Traits, class _Allocator>
1840	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)	1834	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
1841	: __r_(__second_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))	1835	: __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
1842	{	1836	{
1843	if (!__str.__is_long())	1837	if (!__str.__is_long())
1844	__r_.first().__r = __str.__r_.first().__r;	1838	__r_.first().__r = __str.__r_.first().__r;
1845	else	1839	else
1846	__init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());	1840	__init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
1847	#if _LIBCPP_DEBUG_LEVEL >= 2	1841	#if _LIBCPP_DEBUG_LEVEL >= 2
1848	__get_db()->__insert_c(this);	1842	__get_db()->__insert_c(this);
1849	#endif	1843	#endif
...	@@ -1852,12 +1846,12 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st	...	@@ -1852,12 +1846,12 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
1852	template <class _CharT, class _Traits, class _Allocator>	1846	template <class _CharT, class _Traits, class _Allocator>
1853	basic_string<_CharT, _Traits, _Allocator>::basic_string(	1847	basic_string<_CharT, _Traits, _Allocator>::basic_string(
1854	const basic_string& __str, const allocator_type& __a)	1848	const basic_string& __str, const allocator_type& __a)
1855	: __r_(__second_tag(), __a)	1849	: __r_(__default_init_tag(), __a)
1856	{	1850	{
1857	if (!__str.__is_long())	1851	if (!__str.__is_long())
1858	__r_.first().__r = __str.__r_.first().__r;	1852	__r_.first().__r = __str.__r_.first().__r;
1859	else	1853	else
1860	__init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());	1854	__init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
1861	#if _LIBCPP_DEBUG_LEVEL >= 2	1855	#if _LIBCPP_DEBUG_LEVEL >= 2
1862	__get_db()->__insert_c(this);	1856	__get_db()->__insert_c(this);
1863	#endif	1857	#endif
...	@@ -1886,10 +1880,10 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)	...	@@ -1886,10 +1880,10 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
1886	template <class _CharT, class _Traits, class _Allocator>	1880	template <class _CharT, class _Traits, class _Allocator>
1887	inline	1881	inline
1888	basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)	1882	basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
1889	: __r_(__second_tag(), __a)	1883	: __r_(__default_init_tag(), __a)
1890	{	1884	{
1891	if (__str.__is_long() && __a != __str.__alloc()) // copy, not move	1885	if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
1892	__init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());	1886	__init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
1893	else	1887	else
1894	{	1888	{
1895	__r_.first().__r = __str.__r_.first().__r;	1889	__r_.first().__r = __str.__r_.first().__r;
...	@@ -1924,13 +1918,14 @@ basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)	...	@@ -1924,13 +1918,14 @@ basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
1924	__set_long_cap(__cap+1);	1918	__set_long_cap(__cap+1);
1925	__set_long_size(__n);	1919	__set_long_size(__n);
1926	}	1920	}
1927	traits_type::assign(_VSTD::__to_raw_pointer(__p), __n, __c);	1921	traits_type::assign(_VSTD::__to_address(__p), __n, __c);
1928	traits_type::assign(__p[__n], value_type());	1922	traits_type::assign(__p[__n], value_type());
1929	}	1923	}
1930		1924
1931	template <class _CharT, class _Traits, class _Allocator>	1925	template <class _CharT, class _Traits, class _Allocator>
1932	inline	1926	inline
1933	basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)	1927	basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
		1928	: __r_(__default_init_tag(), __default_init_tag())
1934	{	1929	{
1935	__init(__n, __c);	1930	__init(__n, __c);
1936	#if _LIBCPP_DEBUG_LEVEL >= 2	1931	#if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -1939,11 +1934,9 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __	...	@@ -1939,11 +1934,9 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __
1939	}	1934	}
1940		1935
1941	template <class _CharT, class _Traits, class _Allocator>	1936	template <class _CharT, class _Traits, class _Allocator>
1942	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1943	template <class>	1937	template <class>
1944	#endif
1945	basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)	1938	basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
1946	: __r_(__second_tag(), __a)	1939	: __r_(__default_init_tag(), __a)
1947	{	1940	{
1948	__init(__n, __c);	1941	__init(__n, __c);
1949	#if _LIBCPP_DEBUG_LEVEL >= 2	1942	#if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -1955,7 +1948,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -1955,7 +1948,7 @@ template <class _CharT, class _Traits, class _Allocator>
1955	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,	1948	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
1956	size_type __pos, size_type __n,	1949	size_type __pos, size_type __n,
1957	const _Allocator& __a)	1950	const _Allocator& __a)
1958	: __r_(__second_tag(), __a)	1951	: __r_(__default_init_tag(), __a)
1959	{	1952	{
1960	size_type __str_sz = __str.size();	1953	size_type __str_sz = __str.size();
1961	if (__pos > __str_sz)	1954	if (__pos > __str_sz)
...	@@ -1970,7 +1963,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -1970,7 +1963,7 @@ template <class _CharT, class _Traits, class _Allocator>
1970	inline	1963	inline
1971	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,	1964	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
1972	const _Allocator& __a)	1965	const _Allocator& __a)
1973	: __r_(__second_tag(), __a)	1966	: __r_(__default_init_tag(), __a)
1974	{	1967	{
1975	size_type __str_sz = __str.size();	1968	size_type __str_sz = __str.size();
1976	if (__pos > __str_sz)	1969	if (__pos > __str_sz)
...	@@ -1985,7 +1978,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -1985,7 +1978,7 @@ template <class _CharT, class _Traits, class _Allocator>
1985	template <class _Tp, class>	1978	template <class _Tp, class>
1986	basic_string<_CharT, _Traits, _Allocator>::basic_string(	1979	basic_string<_CharT, _Traits, _Allocator>::basic_string(
1987	const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)	1980	const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
1988	: __r_(__second_tag(), __a)	1981	: __r_(__default_init_tag(), __a)
1989	{	1982	{
1990	__self_view __sv0 = __t;	1983	__self_view __sv0 = __t;
1991	__self_view __sv = __sv0.substr(__pos, __n);	1984	__self_view __sv = __sv0.substr(__pos, __n);
...	@@ -1998,6 +1991,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(	...	@@ -1998,6 +1991,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(
1998	template <class _CharT, class _Traits, class _Allocator>	1991	template <class _CharT, class _Traits, class _Allocator>
1999	template <class _Tp, class>	1992	template <class _Tp, class>
2000	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)	1993	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
		1994	: __r_(__default_init_tag(), __default_init_tag())
2001	{	1995	{
2002	__self_view __sv = __t;	1996	__self_view __sv = __t;
2003	__init(__sv.data(), __sv.size());	1997	__init(__sv.data(), __sv.size());
...	@@ -2009,7 +2003,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)	...	@@ -2009,7 +2003,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
2009	template <class _CharT, class _Traits, class _Allocator>	2003	template <class _CharT, class _Traits, class _Allocator>
2010	template <class _Tp, class>	2004	template <class _Tp, class>
2011	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)	2005	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
2012	: __r_(__second_tag(), __a)	2006	: __r_(__default_init_tag(), __a)
2013	{	2007	{
2014	__self_view __sv = __t;	2008	__self_view __sv = __t;
2015	__init(__sv.data(), __sv.size());	2009	__init(__sv.data(), __sv.size());
...	@@ -2022,7 +2016,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2022,7 +2016,7 @@ template <class _CharT, class _Traits, class _Allocator>
2022	template <class _InputIterator>	2016	template <class _InputIterator>
2023	typename enable_if	2017	typename enable_if
2024	<	2018	<
2025	__is_exactly_input_iterator<_InputIterator>::value,	2019	__is_exactly_cpp17_input_iterator<_InputIterator>::value,
2026	void	2020	void
2027	>::type	2021	>::type
2028	basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)	2022	basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
...	@@ -2049,7 +2043,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2049,7 +2043,7 @@ template <class _CharT, class _Traits, class _Allocator>
2049	template <class _ForwardIterator>	2043	template <class _ForwardIterator>
2050	typename enable_if	2044	typename enable_if
2051	<	2045	<
2052	__is_forward_iterator<_ForwardIterator>::value,	2046	__is_cpp17_forward_iterator<_ForwardIterator>::value,
2053	void	2047	void
2054	>::type	2048	>::type
2055	basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)	2049	basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
...	@@ -2080,6 +2074,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2080,6 +2074,7 @@ template <class _CharT, class _Traits, class _Allocator>
2080	template<class _InputIterator, class>	2074	template<class _InputIterator, class>
2081	inline	2075	inline
2082	basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)	2076	basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
		2077	: __r_(__default_init_tag(), __default_init_tag())
2083	{	2078	{
2084	__init(__first, __last);	2079	__init(__first, __last);
2085	#if _LIBCPP_DEBUG_LEVEL >= 2	2080	#if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -2092,7 +2087,7 @@ template<class _InputIterator, class>	...	@@ -2092,7 +2087,7 @@ template<class _InputIterator, class>
2092	inline	2087	inline
2093	basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,	2088	basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
2094	const allocator_type& __a)	2089	const allocator_type& __a)
2095	: __r_(__second_tag(), __a)	2090	: __r_(__default_init_tag(), __a)
2096	{	2091	{
2097	__init(__first, __last);	2092	__init(__first, __last);
2098	#if _LIBCPP_DEBUG_LEVEL >= 2	2093	#if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -2106,6 +2101,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2106,6 +2101,7 @@ template <class _CharT, class _Traits, class _Allocator>
2106	inline	2101	inline
2107	basic_string<_CharT, _Traits, _Allocator>::basic_string(	2102	basic_string<_CharT, _Traits, _Allocator>::basic_string(
2108	initializer_list<_CharT> __il)	2103	initializer_list<_CharT> __il)
		2104	: __r_(__default_init_tag(), __default_init_tag())
2109	{	2105	{
2110	__init(__il.begin(), __il.end());	2106	__init(__il.begin(), __il.end());
2111	#if _LIBCPP_DEBUG_LEVEL >= 2	2107	#if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -2118,7 +2114,7 @@ inline	...	@@ -2118,7 +2114,7 @@ inline
2118		2114
2119	basic_string<_CharT, _Traits, _Allocator>::basic_string(	2115	basic_string<_CharT, _Traits, _Allocator>::basic_string(
2120	initializer_list<_CharT> __il, const _Allocator& __a)	2116	initializer_list<_CharT> __il, const _Allocator& __a)
2121	: __r_(__second_tag(), __a)	2117	: __r_(__default_init_tag(), __a)
2122	{	2118	{
2123	__init(__il.begin(), __il.end());	2119	__init(__il.begin(), __il.end());
2124	#if _LIBCPP_DEBUG_LEVEL >= 2	2120	#if _LIBCPP_DEBUG_LEVEL >= 2
...	@@ -2154,14 +2150,14 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace	...	@@ -2154,14 +2150,14 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
2154	pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);	2150	pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
2155	__invalidate_all_iterators();	2151	__invalidate_all_iterators();
2156	if (__n_copy != 0)	2152	if (__n_copy != 0)
2157	traits_type::copy(_VSTD::__to_raw_pointer(__p),	2153	traits_type::copy(_VSTD::__to_address(__p),
2158	_VSTD::__to_raw_pointer(__old_p), __n_copy);	2154	_VSTD::__to_address(__old_p), __n_copy);
2159	if (__n_add != 0)	2155	if (__n_add != 0)
2160	traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy, __p_new_stuff, __n_add);	2156	traits_type::copy(_VSTD::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
2161	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;	2157	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2162	if (__sec_cp_sz != 0)	2158	if (__sec_cp_sz != 0)
2163	traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add,	2159	traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
2164	_VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del, __sec_cp_sz);	2160	_VSTD::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
2165	if (__old_cap+1 != __min_cap)	2161	if (__old_cap+1 != __min_cap)
2166	__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);	2162	__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
2167	__set_long_pointer(__p);	2163	__set_long_pointer(__p);
...	@@ -2186,12 +2182,12 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t	...	@@ -2186,12 +2182,12 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t
2186	pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);	2182	pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
2187	__invalidate_all_iterators();	2183	__invalidate_all_iterators();
2188	if (__n_copy != 0)	2184	if (__n_copy != 0)
2189	traits_type::copy(_VSTD::__to_raw_pointer(__p),	2185	traits_type::copy(_VSTD::__to_address(__p),
2190	_VSTD::__to_raw_pointer(__old_p), __n_copy);	2186	_VSTD::__to_address(__old_p), __n_copy);
2191	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;	2187	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2192	if (__sec_cp_sz != 0)	2188	if (__sec_cp_sz != 0)
2193	traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add,	2189	traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
2194	_VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del,	2190	_VSTD::__to_address(__old_p) + __n_copy + __n_del,
2195	__sec_cp_sz);	2191	__sec_cp_sz);
2196	if (__old_cap+1 != __min_cap)	2192	if (__old_cap+1 != __min_cap)
2197	__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);	2193	__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
...	@@ -2209,7 +2205,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_ty	...	@@ -2209,7 +2205,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_ty
2209	size_type __cap = capacity();	2205	size_type __cap = capacity();
2210	if (__cap >= __n)	2206	if (__cap >= __n)
2211	{	2207	{
2212	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());	2208	value_type* __p = _VSTD::__to_address(__get_pointer());
2213	traits_type::move(__p, __s, __n);	2209	traits_type::move(__p, __s, __n);
2214	traits_type::assign(__p[__n], value_type());	2210	traits_type::assign(__p[__n], value_type());
2215	__set_size(__n);	2211	__set_size(__n);
...	@@ -2235,7 +2231,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)	...	@@ -2235,7 +2231,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
2235	}	2231	}
2236	else	2232	else
2237	__invalidate_iterators_past(__n);	2233	__invalidate_iterators_past(__n);
2238	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());	2234	value_type* __p = _VSTD::__to_address(__get_pointer());
2239	traits_type::assign(__p, __n, __c);	2235	traits_type::assign(__p, __n, __c);
2240	traits_type::assign(__p[__n], value_type());	2236	traits_type::assign(__p[__n], value_type());
2241	__set_size(__n);	2237	__set_size(__n);
...	@@ -2270,7 +2266,7 @@ basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)	...	@@ -2270,7 +2266,7 @@ basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
2270	if (this != &__str)	2266	if (this != &__str)
2271	{	2267	{
2272	__copy_assign_alloc(__str);	2268	__copy_assign_alloc(__str);
2273	assign(__str.data(), __str.size());	2269	return assign(__str.data(), __str.size());
2274	}	2270	}
2275	return *this;	2271	return *this;
2276	}	2272	}
...	@@ -2299,10 +2295,20 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr	...	@@ -2299,10 +2295,20 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr
2299	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)	2295	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
2300	#endif	2296	#endif
2301	{	2297	{
2302	__clear_and_shrink();	2298	if (__is_long()) {
2303	__r_.first() = __str.__r_.first();	2299	__alloc_traits::deallocate(__alloc(), __get_long_pointer(),
2304	__move_assign_alloc(__str);	2300	__get_long_cap());
2305	__str.__zero();	2301	#if _LIBCPP_STD_VER <= 14
		2302	if (!is_nothrow_move_assignable<allocator_type>::value) {
		2303	__set_short_size(0);
		2304	traits_type::assign(__get_short_pointer()[0], value_type());
		2305	}
		2306	#endif
		2307	}
		2308	__move_assign_alloc(__str);
		2309	__r_.first() = __str.__r_.first();
		2310	__str.__set_short_size(0);
		2311	traits_type::assign(__str.__get_short_pointer()[0], value_type());
2306	}	2312	}
2307		2313
2308	template <class _CharT, class _Traits, class _Allocator>	2314	template <class _CharT, class _Traits, class _Allocator>
...	@@ -2322,7 +2328,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2322,7 +2328,7 @@ template <class _CharT, class _Traits, class _Allocator>
2322	template<class _InputIterator>	2328	template<class _InputIterator>
2323	typename enable_if	2329	typename enable_if
2324	<	2330	<
2325	__is_exactly_input_iterator <_InputIterator>::value	2331	__is_exactly_cpp17_input_iterator <_InputIterator>::value
2326	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,	2332	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
2327	basic_string<_CharT, _Traits, _Allocator>&	2333	basic_string<_CharT, _Traits, _Allocator>&
2328	>::type	2334	>::type
...	@@ -2337,7 +2343,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2337,7 +2343,7 @@ template <class _CharT, class _Traits, class _Allocator>
2337	template<class _ForwardIterator>	2343	template<class _ForwardIterator>
2338	typename enable_if	2344	typename enable_if
2339	<	2345	<
2340	__is_forward_iterator<_ForwardIterator>::value	2346	__is_cpp17_forward_iterator<_ForwardIterator>::value
2341	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,	2347	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
2342	basic_string<_CharT, _Traits, _Allocator>&	2348	basic_string<_CharT, _Traits, _Allocator>&
2343	>::type	2349	>::type
...	@@ -2408,7 +2414,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_ty	...	@@ -2408,7 +2414,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_ty
2408	{	2414	{
2409	if (__n)	2415	if (__n)
2410	{	2416	{
2411	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());	2417	value_type* __p = _VSTD::__to_address(__get_pointer());
2412	traits_type::copy(__p + __sz, __s, __n);	2418	traits_type::copy(__p + __sz, __s, __n);
2413	__sz += __n;	2419	__sz += __n;
2414	__set_size(__sz);	2420	__set_size(__sz);
...	@@ -2431,7 +2437,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)	...	@@ -2431,7 +2437,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
2431	if (__cap - __sz < __n)	2437	if (__cap - __sz < __n)
2432	__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);	2438	__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
2433	pointer __p = __get_pointer();	2439	pointer __p = __get_pointer();
2434	traits_type::assign(_VSTD::__to_raw_pointer(__p) + __sz, __n, __c);	2440	traits_type::assign(_VSTD::__to_address(__p) + __sz, __n, __c);
2435	__sz += __n;	2441	__sz += __n;
2436	__set_size(__sz);	2442	__set_size(__sz);
2437	traits_type::assign(__p[__sz], value_type());	2443	traits_type::assign(__p[__sz], value_type());
...	@@ -2511,7 +2517,7 @@ basic_string<_CharT, _Traits, _Allocator>&	...	@@ -2511,7 +2517,7 @@ basic_string<_CharT, _Traits, _Allocator>&
2511	basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe(	2517	basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe(
2512	_ForwardIterator __first, _ForwardIterator __last)	2518	_ForwardIterator __first, _ForwardIterator __last)
2513	{	2519	{
2514	static_assert(__is_forward_iterator<_ForwardIterator>::value,	2520	static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
2515	"function requires a ForwardIterator");	2521	"function requires a ForwardIterator");
2516	size_type __sz = size();	2522	size_type __sz = size();
2517	size_type __cap = capacity();	2523	size_type __cap = capacity();
...	@@ -2596,7 +2602,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_t	...	@@ -2596,7 +2602,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_t
2596	{	2602	{
2597	if (__n)	2603	if (__n)
2598	{	2604	{
2599	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());	2605	value_type* __p = _VSTD::__to_address(__get_pointer());
2600	size_type __n_move = __sz - __pos;	2606	size_type __n_move = __sz - __pos;
2601	if (__n_move != 0)	2607	if (__n_move != 0)
2602	{	2608	{
...	@@ -2628,7 +2634,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n	...	@@ -2628,7 +2634,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n
2628	value_type* __p;	2634	value_type* __p;
2629	if (__cap - __sz >= __n)	2635	if (__cap - __sz >= __n)
2630	{	2636	{
2631	__p = _VSTD::__to_raw_pointer(__get_pointer());	2637	__p = _VSTD::__to_address(__get_pointer());
2632	size_type __n_move = __sz - __pos;	2638	size_type __n_move = __sz - __pos;
2633	if (__n_move != 0)	2639	if (__n_move != 0)
2634	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);	2640	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
...	@@ -2636,7 +2642,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n	...	@@ -2636,7 +2642,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n
2636	else	2642	else
2637	{	2643	{
2638	__grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);	2644	__grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
2639	__p = _VSTD::__to_raw_pointer(__get_long_pointer());	2645	__p = _VSTD::__to_address(__get_long_pointer());
2640	}	2646	}
2641	traits_type::assign(__p + __pos, __n, __c);	2647	traits_type::assign(__p + __pos, __n, __c);
2642	__sz += __n;	2648	__sz += __n;
...	@@ -2650,7 +2656,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2650,7 +2656,7 @@ template <class _CharT, class _Traits, class _Allocator>
2650	template<class _InputIterator>	2656	template<class _InputIterator>
2651	typename enable_if	2657	typename enable_if
2652	<	2658	<
2653	__is_exactly_input_iterator<_InputIterator>::value	2659	__is_exactly_cpp17_input_iterator<_InputIterator>::value
2654	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,	2660	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
2655	typename basic_string<_CharT, _Traits, _Allocator>::iterator	2661	typename basic_string<_CharT, _Traits, _Allocator>::iterator
2656	>::type	2662	>::type
...	@@ -2669,7 +2675,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2669,7 +2675,7 @@ template <class _CharT, class _Traits, class _Allocator>
2669	template<class _ForwardIterator>	2675	template<class _ForwardIterator>
2670	typename enable_if	2676	typename enable_if
2671	<	2677	<
2672	__is_forward_iterator<_ForwardIterator>::value	2678	__is_cpp17_forward_iterator<_ForwardIterator>::value
2673	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,	2679	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
2674	typename basic_string<_CharT, _Traits, _Allocator>::iterator	2680	typename basic_string<_CharT, _Traits, _Allocator>::iterator
2675	>::type	2681	>::type
...	@@ -2697,7 +2703,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _Forward	...	@@ -2697,7 +2703,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _Forward
2697	value_type* __p;	2703	value_type* __p;
2698	if (__cap - __sz >= __n)	2704	if (__cap - __sz >= __n)
2699	{	2705	{
2700	__p = _VSTD::__to_raw_pointer(__get_pointer());	2706	__p = _VSTD::__to_address(__get_pointer());
2701	size_type __n_move = __sz - __ip;	2707	size_type __n_move = __sz - __ip;
2702	if (__n_move != 0)	2708	if (__n_move != 0)
2703	traits_type::move(__p + __ip + __n, __p + __ip, __n_move);	2709	traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
...	@@ -2705,7 +2711,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _Forward	...	@@ -2705,7 +2711,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _Forward
2705	else	2711	else
2706	{	2712	{
2707	__grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);	2713	__grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
2708	__p = _VSTD::__to_raw_pointer(__get_long_pointer());	2714	__p = _VSTD::__to_address(__get_long_pointer());
2709	}	2715	}
2710	__sz += __n;	2716	__sz += __n;
2711	__set_size(__sz);	2717	__set_size(__sz);
...	@@ -2771,11 +2777,11 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_ty	...	@@ -2771,11 +2777,11 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_ty
2771	if (__cap == __sz)	2777	if (__cap == __sz)
2772	{	2778	{
2773	__grow_by(__cap, 1, __sz, __ip, 0, 1);	2779	__grow_by(__cap, 1, __sz, __ip, 0, 1);
2774	__p = _VSTD::__to_raw_pointer(__get_long_pointer());	2780	__p = _VSTD::__to_address(__get_long_pointer());
2775	}	2781	}
2776	else	2782	else
2777	{	2783	{
2778	__p = _VSTD::__to_raw_pointer(__get_pointer());	2784	__p = _VSTD::__to_address(__get_pointer());
2779	size_type __n_move = __sz - __ip;	2785	size_type __n_move = __sz - __ip;
2780	if (__n_move != 0)	2786	if (__n_move != 0)
2781	traits_type::move(__p + __ip + 1, __p + __ip, __n_move);	2787	traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
...	@@ -2816,7 +2822,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __	...	@@ -2816,7 +2822,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
2816	size_type __cap = capacity();	2822	size_type __cap = capacity();
2817	if (__cap - __sz + __n1 >= __n2)	2823	if (__cap - __sz + __n1 >= __n2)
2818	{	2824	{
2819	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());	2825	value_type* __p = _VSTD::__to_address(__get_pointer());
2820	if (__n1 != __n2)	2826	if (__n1 != __n2)
2821	{	2827	{
2822	size_type __n_move = __sz - __pos - __n1;	2828	size_type __n_move = __sz - __pos - __n1;
...	@@ -2871,7 +2877,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __	...	@@ -2871,7 +2877,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
2871	value_type* __p;	2877	value_type* __p;
2872	if (__cap - __sz + __n1 >= __n2)	2878	if (__cap - __sz + __n1 >= __n2)
2873	{	2879	{
2874	__p = _VSTD::__to_raw_pointer(__get_pointer());	2880	__p = _VSTD::__to_address(__get_pointer());
2875	if (__n1 != __n2)	2881	if (__n1 != __n2)
2876	{	2882	{
2877	size_type __n_move = __sz - __pos - __n1;	2883	size_type __n_move = __sz - __pos - __n1;
...	@@ -2882,7 +2888,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __	...	@@ -2882,7 +2888,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
2882	else	2888	else
2883	{	2889	{
2884	__grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);	2890	__grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
2885	__p = _VSTD::__to_raw_pointer(__get_long_pointer());	2891	__p = _VSTD::__to_address(__get_long_pointer());
2886	}	2892	}
2887	traits_type::assign(__p + __pos, __n2, __c);	2893	traits_type::assign(__p + __pos, __n2, __c);
2888	__sz += __n2 - __n1;	2894	__sz += __n2 - __n1;
...	@@ -2896,7 +2902,7 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2896,7 +2902,7 @@ template <class _CharT, class _Traits, class _Allocator>
2896	template<class _InputIterator>	2902	template<class _InputIterator>
2897	typename enable_if	2903	typename enable_if
2898	<	2904	<
2899	__is_input_iterator<_InputIterator>::value,	2905	__is_cpp17_input_iterator<_InputIterator>::value,
2900	basic_string<_CharT, _Traits, _Allocator>&	2906	basic_string<_CharT, _Traits, _Allocator>&
2901	>::type	2907	>::type
2902	basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,	2908	basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
...	@@ -2994,7 +3000,7 @@ basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)	...	@@ -2994,7 +3000,7 @@ basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)
2994	this->__throw_out_of_range();	3000	this->__throw_out_of_range();
2995	if (__n)	3001	if (__n)
2996	{	3002	{
2997	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());	3003	value_type* __p = _VSTD::__to_address(__get_pointer());
2998	__n = _VSTD::min(__n, __sz - __pos);	3004	__n = _VSTD::min(__n, __sz - __pos);
2999	size_type __n_move = __sz - __pos - __n;	3005	size_type __n_move = __sz - __pos - __n;
3000	if (__n_move != 0)	3006	if (__n_move != 0)
...	@@ -3182,8 +3188,8 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)	...	@@ -3182,8 +3188,8 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
3182	__was_long = __is_long();	3188	__was_long = __is_long();
3183	__p = __get_pointer();	3189	__p = __get_pointer();
3184	}	3190	}
3185	traits_type::copy(_VSTD::__to_raw_pointer(__new_data),	3191	traits_type::copy(_VSTD::__to_address(__new_data),
3186	_VSTD::__to_raw_pointer(__p), size()+1);	3192	_VSTD::__to_address(__p), size()+1);
3187	if (__was_long)	3193	if (__was_long)
3188	__alloc_traits::deallocate(__alloc(), __p, __cap+1);	3194	__alloc_traits::deallocate(__alloc(), __p, __cap+1);
3189	if (__now_long)	3195	if (__now_long)
...	@@ -4294,23 +4300,23 @@ template<class _CharT, class _Traits, class _Allocator>	...	@@ -4294,23 +4300,23 @@ template<class _CharT, class _Traits, class _Allocator>
4294	bool	4300	bool
4295	basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const	4301	basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
4296	{	4302	{
4297	return this->data() <= _VSTD::__to_raw_pointer(__i->base()) &&	4303	return this->data() <= _VSTD::__to_address(__i->base()) &&
4298	_VSTD::__to_raw_pointer(__i->base()) < this->data() + this->size();	4304	_VSTD::__to_address(__i->base()) < this->data() + this->size();
4299	}	4305	}
4300		4306
4301	template<class _CharT, class _Traits, class _Allocator>	4307	template<class _CharT, class _Traits, class _Allocator>
4302	bool	4308	bool
4303	basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const	4309	basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
4304	{	4310	{
4305	return this->data() < _VSTD::__to_raw_pointer(__i->base()) &&	4311	return this->data() < _VSTD::__to_address(__i->base()) &&
4306	_VSTD::__to_raw_pointer(__i->base()) <= this->data() + this->size();	4312	_VSTD::__to_address(__i->base()) <= this->data() + this->size();
4307	}	4313	}
4308		4314
4309	template<class _CharT, class _Traits, class _Allocator>	4315	template<class _CharT, class _Traits, class _Allocator>
4310	bool	4316	bool
4311	basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const	4317	basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
4312	{	4318	{
4313	const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n;	4319	const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
4314	return this->data() <= __p && __p <= this->data() + this->size();	4320	return this->data() <= __p && __p <= this->data() + this->size();
4315	}	4321	}
4316		4322
...	@@ -4318,7 +4324,7 @@ template<class _CharT, class _Traits, class _Allocator>	...	@@ -4318,7 +4324,7 @@ template<class _CharT, class _Traits, class _Allocator>
4318	bool	4324	bool
4319	basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const	4325	basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
4320	{	4326	{
4321	const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n;	4327	const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
4322	return this->data() <= __p && __p < this->data() + this->size();	4328	return this->data() <= __p && __p < this->data() + this->size();
4323	}	4329	}
4324		4330

lib/libcxx/include/string_view+8-1

...	@@ -173,6 +173,7 @@ namespace std {	...	@@ -173,6 +173,7 @@ namespace std {
173		173
174	#include <__config>	174	#include <__config>
175	#include <__string>	175	#include <__string>
		176	#include <iosfwd>
176	#include <algorithm>	177	#include <algorithm>
177	#include <iterator>	178	#include <iterator>
178	#include <limits>	179	#include <limits>
...	@@ -235,7 +236,7 @@ public:	...	@@ -235,7 +236,7 @@ public:
235		236
236	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY	237	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
237	basic_string_view(const _CharT* __s)	238	basic_string_view(const _CharT* __s)
238	: __data(__s), __size(_Traits::length(__s)) {}	239	: __data(__s), __size(std::__char_traits_length_checked<_Traits>(__s)) {}
239		240
240	// [string.view.iterators], iterators	241	// [string.view.iterators], iterators
241	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY	242	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
...	@@ -767,6 +768,12 @@ bool operator>=(typename common_type<basic_string_view<_CharT, _Traits> >::type	...	@@ -767,6 +768,12 @@ bool operator>=(typename common_type<basic_string_view<_CharT, _Traits> >::type
767	return __lhs.compare(__rhs) >= 0;	768	return __lhs.compare(__rhs) >= 0;
768	}	769	}
769		770
		771
		772	template<class _CharT, class _Traits>
		773	basic_ostream<_CharT, _Traits>&
		774	operator<<(basic_ostream<_CharT, _Traits>& __os,
		775	basic_string_view<_CharT, _Traits> __str);
		776
770	typedef basic_string_view<char> string_view;	777	typedef basic_string_view<char> string_view;
771	#ifndef _LIBCPP_NO_HAS_CHAR8_T	778	#ifndef _LIBCPP_NO_HAS_CHAR8_T
772	typedef basic_string_view<char8_t> u8string_view;	779	typedef basic_string_view<char8_t> u8string_view;

lib/libcxx/include/support/android/locale_bionic.h+2

 @@ -27,7 +27,9 @@ extern "C" {
 #include <android/api-level.h>
 #include <android/ndk-version.h>
+#if __ANDROID_API__ < 21
 #include <support/xlocale/__posix_l_fallback.h>
+#endif
 // In NDK versions later than 16, locale-aware functions are provided by
 // legacy_stdlib_inlines.h
 #if __NDK_MAJOR__ <= 16

lib/libcxx/include/support/ibm/xlocale.h+3-3

...	@@ -87,7 +87,7 @@ int isxdigit_l(int c, locale_t locale)	...	@@ -87,7 +87,7 @@ int isxdigit_l(int c, locale_t locale)
87	static inline	87	static inline
88	int iswalnum_l(wchar_t wc, locale_t locale)	88	int iswalnum_l(wchar_t wc, locale_t locale)
89	{	89	{
90	return __xiswalnum(locale, wc);	90	return __xiswalnum(locale, wc);
91	}	91	}
92		92
93	static inline	93	static inline
...	@@ -159,7 +159,7 @@ int iswxdigit_l(wchar_t wc, locale_t locale)	...	@@ -159,7 +159,7 @@ int iswxdigit_l(wchar_t wc, locale_t locale)
159	static inline	159	static inline
160	int iswctype_l(wint_t wc, wctype_t desc, locale_t locale)	160	int iswctype_l(wint_t wc, wctype_t desc, locale_t locale)
161	{	161	{
162	return __xiswctype(locale, wc, desc);	162	return __xiswctype(locale, wc, desc);
163	}	163	}
164		164
165	static inline	165	static inline
...	@@ -261,7 +261,7 @@ int vasprintf(char *strp, const char fmt, va_list ap)	...	@@ -261,7 +261,7 @@ int vasprintf(char *strp, const char fmt, va_list ap)
261	str_size = vsnprintf(*strp, str_size + 1, fmt, ap);	261	str_size = vsnprintf(*strp, str_size + 1, fmt, ap);
262	}	262	}
263	return str_size;	263	return str_size;
264	}	264	}
265		265
266	#ifdef __cplusplus	266	#ifdef __cplusplus
267	}	267	}

lib/libcxx/include/support/solaris/wchar.h+1-1

...	@@ -26,7 +26,7 @@	...	@@ -26,7 +26,7 @@
26	#define wctype sun_wctype	26	#define wctype sun_wctype
27	#define _WCHAR_T 1	27	#define _WCHAR_T 1
28	#include_next "wchar.h"	28	#include_next "wchar.h"
29	#undef iswalpha	29	#undef iswalpha
30	#undef iswupper	30	#undef iswupper
31	#undef iswlower	31	#undef iswlower
32	#undef iswdigit	32	#undef iswdigit

lib/libcxx/include/support/win32/locale_win32.h+71-5

...	@@ -28,14 +28,72 @@	...	@@ -28,14 +28,72 @@
28	\| LC_NUMERIC_MASK \	28	\| LC_NUMERIC_MASK \
29	\| LC_TIME_MASK )	29	\| LC_TIME_MASK )
30		30
		31	class __lconv_storage {
		32	public:
		33	__lconv_storage(const lconv *__lc_input) {
		34	__lc = *__lc_input;
		35
		36	__decimal_point = __lc_input->decimal_point;
		37	__thousands_sep = __lc_input->thousands_sep;
		38	__grouping = __lc_input->grouping;
		39	__int_curr_symbol = __lc_input->int_curr_symbol;
		40	__currency_symbol = __lc_input->currency_symbol;
		41	__mon_decimal_point = __lc_input->mon_decimal_point;
		42	__mon_thousands_sep = __lc_input->mon_thousands_sep;
		43	__mon_grouping = __lc_input->mon_grouping;
		44	__positive_sign = __lc_input->positive_sign;
		45	__negative_sign = __lc_input->negative_sign;
		46
		47	__lc.decimal_point = const_cast<char *>(__decimal_point.c_str());
		48	__lc.thousands_sep = const_cast<char *>(__thousands_sep.c_str());
		49	__lc.grouping = const_cast<char *>(__grouping.c_str());
		50	__lc.int_curr_symbol = const_cast<char *>(__int_curr_symbol.c_str());
		51	__lc.currency_symbol = const_cast<char *>(__currency_symbol.c_str());
		52	__lc.mon_decimal_point = const_cast<char *>(__mon_decimal_point.c_str());
		53	__lc.mon_thousands_sep = const_cast<char *>(__mon_thousands_sep.c_str());
		54	__lc.mon_grouping = const_cast<char *>(__mon_grouping.c_str());
		55	__lc.positive_sign = const_cast<char *>(__positive_sign.c_str());
		56	__lc.negative_sign = const_cast<char *>(__negative_sign.c_str());
		57	}
		58
		59	lconv *__get() {
		60	return &__lc;
		61	}
		62	private:
		63	lconv __lc;
		64	std::string __decimal_point;
		65	std::string __thousands_sep;
		66	std::string __grouping;
		67	std::string __int_curr_symbol;
		68	std::string __currency_symbol;
		69	std::string __mon_decimal_point;
		70	std::string __mon_thousands_sep;
		71	std::string __mon_grouping;
		72	std::string __positive_sign;
		73	std::string __negative_sign;
		74	};
		75
31	class locale_t {	76	class locale_t {
32	public:	77	public:
33	locale_t()	78	locale_t()
34	: __locale(nullptr), __locale_str(nullptr) {}	79	: __locale(nullptr), __locale_str(nullptr), __lc(nullptr) {}
35	locale_t(std::nullptr_t)	80	locale_t(std::nullptr_t)
36	: __locale(nullptr), __locale_str(nullptr) {}	81	: __locale(nullptr), __locale_str(nullptr), __lc(nullptr) {}
37	locale_t(_locale_t __xlocale, const char* __xlocale_str)	82	locale_t(_locale_t __xlocale, const char* __xlocale_str)
38	: __locale(__xlocale), __locale_str(__xlocale_str) {}	83	: __locale(__xlocale), __locale_str(__xlocale_str), __lc(nullptr) {}
		84	locale_t(const locale_t &__l)
		85	: __locale(__l.__locale), __locale_str(__l.__locale_str), __lc(nullptr) {}
		86
		87	~locale_t() {
		88	delete __lc;
		89	}
		90
		91	locale_t &operator =(const locale_t &__l) {
		92	__locale = __l.__locale;
		93	__locale_str = __l.__locale_str;
		94	// __lc not copied
		95	return *this;
		96	}
39		97
40	friend bool operator==(const locale_t& __left, const locale_t& __right) {	98	friend bool operator==(const locale_t& __left, const locale_t& __right) {
41	return __left.__locale == __right.__locale;	99	return __left.__locale == __right.__locale;
...	@@ -94,9 +152,16 @@ public:	...	@@ -94,9 +152,16 @@ public:
94	operator _locale_t() const {	152	operator _locale_t() const {
95	return __locale;	153	return __locale;
96	}	154	}
		155
		156	lconv __store_lconv(const lconv __input_lc) {
		157	delete __lc;
		158	__lc = new __lconv_storage(__input_lc);
		159	return __lc->__get();
		160	}
97	private:	161	private:
98	_locale_t __locale;	162	_locale_t __locale;
99	const char* __locale_str;	163	const char* __locale_str;
		164	__lconv_storage *__lc = nullptr;
100	};	165	};
101		166
102	// Locale management functions	167	// Locale management functions
...	@@ -109,7 +174,7 @@ locale_t newlocale( int mask, const char * locale, locale_t base );	...	@@ -109,7 +174,7 @@ locale_t newlocale( int mask, const char * locale, locale_t base );
109	// We can still implement raii even without uselocale though.	174	// We can still implement raii even without uselocale though.
110		175
111		176
112	lconv *localeconv_l( locale_t loc );	177	lconv *localeconv_l( locale_t &loc );
113	size_t mbrlen_l( const char *__restrict s, size_t n,	178	size_t mbrlen_l( const char *__restrict s, size_t n,
114	mbstate_t *__restrict ps, locale_t loc);	179	mbstate_t *__restrict ps, locale_t loc);
115	size_t mbsrtowcs_l( wchar_t __restrict dst, const char *__restrict src,	180	size_t mbsrtowcs_l( wchar_t __restrict dst, const char *__restrict src,
...	@@ -173,7 +238,8 @@ isupper_l(int c, _locale_t loc)	...	@@ -173,7 +238,8 @@ isupper_l(int c, _locale_t loc)
173	#define towupper_l _towupper_l	238	#define towupper_l _towupper_l
174	#define towlower_l _towlower_l	239	#define towlower_l _towlower_l
175	#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800	240	#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800
176	#define strftime_l( __s, __l, __f, __tm, __loc ) strftime( __s, __l, __f, __tm )	241	_LIBCPP_FUNC_VIS size_t strftime_l(char ret, size_t n, const char format,
		242	const struct tm *tm, locale_t loc);
177	#else	243	#else
178	#define strftime_l _strftime_l	244	#define strftime_l _strftime_l
179	#endif	245	#endif

lib/libcxx/include/thread+1-4

...	@@ -14,8 +14,6 @@	...	@@ -14,8 +14,6 @@
14		14
15	thread synopsis	15	thread synopsis
16		16
17	#define __STDCPP_THREADS__ __cplusplus
18
19	namespace std	17	namespace std
20	{	18	{
21		19
...	@@ -107,8 +105,6 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);	...	@@ -107,8 +105,6 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);
107	_LIBCPP_PUSH_MACROS	105	_LIBCPP_PUSH_MACROS
108	#include <__undef_macros>	106	#include <__undef_macros>
109		107
110	#define __STDCPP_THREADS__ __cplusplus
111
112	#ifdef _LIBCPP_HAS_NO_THREADS	108	#ifdef _LIBCPP_HAS_NO_THREADS
113	#error <thread> is not supported on this single threaded system	109	#error <thread> is not supported on this single threaded system
114	#else // !_LIBCPP_HAS_NO_THREADS	110	#else // !_LIBCPP_HAS_NO_THREADS
...	@@ -278,6 +274,7 @@ __thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>)	...	@@ -278,6 +274,7 @@ __thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>)
278	}	274	}
279		275
280	template <class _Fp>	276	template <class _Fp>
		277	_LIBCPP_INLINE_VISIBILITY
281	void* __thread_proxy(void* __vp)	278	void* __thread_proxy(void* __vp)
282	{	279	{
283	// _Fp = std::tuple< unique_ptr<__thread_struct>, Functor, Args...>	280	// _Fp = std::tuple< unique_ptr<__thread_struct>, Functor, Args...>

lib/libcxx/include/tuple+84-45

 @@ -19,40 +19,40 @@ namespace std
 template <class... T>
 class tuple {
 public:
-    constexpr tuple();
+    explicit(see-below) constexpr tuple();
-    explicit tuple(const T&...);  // constexpr in C++14
+    explicit(see-below) tuple(const T&...);  // constexpr in C++14
     template <class... U>
-        explicit tuple(U&&...);  // constexpr in C++14
+        explicit(see-below) tuple(U&&...);  // constexpr in C++14
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
     template <class... U>
-        tuple(const tuple<U...>&);  // constexpr in C++14
+        explicit(see-below) tuple(const tuple<U...>&);  // constexpr in C++14
     template <class... U>
-        tuple(tuple<U...>&&);  // constexpr in C++14
+        explicit(see-below) tuple(tuple<U...>&&);  // constexpr in C++14
     template <class U1, class U2>
-        tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
+        explicit(see-below) tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
     template <class U1, class U2>
-        tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
+        explicit(see-below) tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
     // allocator-extended constructors
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a);
     template <class Alloc>
-        tuple(allocator_arg_t, const Alloc& a, const T&...);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const T&...);
     template <class Alloc, class... U>
-        tuple(allocator_arg_t, const Alloc& a, U&&...);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, U&&...);
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, const tuple&);
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, tuple&&);
     template <class Alloc, class... U>
-        tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
     template <class Alloc, class... U>
-        tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
     template <class Alloc, class U1, class U2>
-        tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
     template <class Alloc, class U1, class U2>
-        tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
     tuple& operator=(const tuple&);
     tuple&
 @@ -69,6 +69,17 @@ public:
     void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
 };
+template <class ...T>
+tuple(T...) -> tuple<T...>;                                         // since C++17
+template <class T1, class T2>
+tuple(pair<T1, T2>) -> tuple<T1, T2>;                               // since C++17
+template <class Alloc, class ...T>
+tuple(allocator_arg_t, Alloc, T...) -> tuple<T...>;                 // since C++17
+template <class Alloc, class T1, class T2>
+tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>;       // since C++17
+template <class Alloc, class ...T>
+tuple(allocator_arg_t, Alloc, tuple<T...>) -> tuple<T...>;          // since C++17
 inline constexpr unspecified ignore;
 template <class... T> tuple<V...>  make_tuple(T&&...); // constexpr in C++14
 @@ -488,11 +499,19 @@ class _LIBCPP_TEMPLATE_VIS tuple
     template <class _Dummy>
     struct _CheckArgsConstructor<true, _Dummy>
     {
-        template <class ..._Args>
+        template <int&...>
-        static constexpr bool __enable_default() {
+        static constexpr bool __enable_implicit_default() {
-            return __all<is_default_constructible<_Args>::value...>::value;
+           return __all<__is_implicitly_default_constructible<_Tp>::value... >::value;
+        }
+        template <int&...>
+        static constexpr bool __enable_explicit_default() {
+            return
+                __all<is_default_constructible<_Tp>::value...>::value &&
+                !__enable_implicit_default< >();
         }
         template <class ..._Args>
         static constexpr bool __enable_explicit() {
             return
 @@ -630,22 +649,26 @@ class _LIBCPP_TEMPLATE_VIS tuple
         const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
 public:
-    template <bool _Dummy = true, class = typename enable_if<
+    template <bool _Dummy = true, _EnableIf<
-        _CheckArgsConstructor<_Dummy>::template __enable_default<_Tp...>()
+        _CheckArgsConstructor<_Dummy>::__enable_implicit_default()
-    >::type>
+    , void*> = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    _LIBCPP_CONSTEXPR tuple()
+    tuple()
+        _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
+    template <bool _Dummy = true, _EnableIf<
+        _CheckArgsConstructor<_Dummy>::__enable_explicit_default()
+    , void*> = nullptr>
+    explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+    tuple()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
     tuple(tuple const&) = default;
     tuple(tuple&&) = default;
-    template <class _AllocArgT, class _Alloc, bool _Dummy = true, class = _EnableIf<
+    template <class _AllocArgT, class _Alloc, _EnableIf<
-        _And<
+             _CheckArgsConstructor<_IsSame<allocator_arg_t, _AllocArgT>::value >::__enable_implicit_default()
-            _IsSame<allocator_arg_t, _AllocArgT>,
+      , void*> = nullptr
-           __dependent_type<is_default_constructible<_Tp>, _Dummy>...
-       >::value
-      >
     >
     _LIBCPP_INLINE_VISIBILITY
     tuple(_AllocArgT, _Alloc const& __a)
 @@ -654,6 +677,17 @@ public:
                     typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
                     __tuple_types<_Tp...>()) {}
+    template <class _AllocArgT, class _Alloc, _EnableIf<
+             _CheckArgsConstructor<_IsSame<allocator_arg_t, _AllocArgT>::value>::__enable_explicit_default()
+      , void*> = nullptr
+    >
+    explicit _LIBCPP_INLINE_VISIBILITY
+    tuple(_AllocArgT, _Alloc const& __a)
+      : __base_(allocator_arg_t(), __a,
+                    __tuple_indices<>(), __tuple_types<>(),
+                    typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
+                    __tuple_types<_Tp...>()) {}
     template <bool _Dummy = true,
               typename enable_if
                       <
 @@ -943,13 +977,16 @@ public:
 };
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
-// NOTE: These are not yet standardized, but are required to simulate the
+template <class ..._Tp>
-// implicit deduction guide that should be generated had libc++ declared the
+tuple(_Tp...) -> tuple<_Tp...>;
-// tuple-like constructors "correctly"
+template <class _Tp1, class _Tp2>
-template <class _Alloc, class ..._Args>
+tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
-tuple(allocator_arg_t, const _Alloc&, tuple<_Args...> const&) -> tuple<_Args...>;
+template <class _Alloc, class ..._Tp>
-template <class _Alloc, class ..._Args>
+tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
-tuple(allocator_arg_t, const _Alloc&, tuple<_Args...>&&) -> tuple<_Args...>;
+template <class _Alloc, class _Tp1, class _Tp2>
+tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
+template <class _Alloc, class ..._Tp>
+tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
 #endif
 template <class ..._Tp>
 @@ -1312,8 +1349,9 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
     operator()(tuple<_Types...> __t, _Tuple0&& __t0)
     {
-        return forward_as_tuple(_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
+        return _VSTD::forward_as_tuple(
-                                      _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
+            _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
+            _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
     }
     template <class _Tuple0, class _Tuple1, class ..._Tuples>
 @@ -1324,15 +1362,16 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
         typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple0>::type _T0;
         typedef _LIBCPP_NODEBUG_TYPE typename remove_reference<_Tuple1>::type _T1;
         return __tuple_cat<
-           tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
+            tuple<_Types...,
-           typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
+                  typename __apply_cv<_Tuple0, typename tuple_element<
-           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
+                                                   _J0, _T0>::type>::type&&...>,
-                           (forward_as_tuple(
+            typename __make_tuple_indices<sizeof...(_Types) +
-                              _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
+                                          tuple_size<_T0>::value>::type,
-                              _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
+            typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(
-                            ),
+            _VSTD::forward_as_tuple(
-                            _VSTD::forward<_Tuple1>(__t1),
+                _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
-                            _VSTD::forward<_Tuples>(__tpls)...);
+                _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...),
+            _VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...);
     }
 };

lib/libcxx/include/type_traits+105-89

...	@@ -427,7 +427,6 @@ template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS pair;	...	@@ -427,7 +427,6 @@ template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS pair;
427	template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;	427	template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;
428	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;	428	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
429		429
430
431	template <class _Tp, _Tp __v>	430	template <class _Tp, _Tp __v>
432	struct _LIBCPP_TEMPLATE_VIS integral_constant	431	struct _LIBCPP_TEMPLATE_VIS integral_constant
433	{	432	{
...	@@ -509,8 +508,8 @@ struct _Lazy : _Func<_Args...> {};	...	@@ -509,8 +508,8 @@ struct _Lazy : _Func<_Args...> {};
509		508
510	// Member detector base	509	// Member detector base
511		510
512	template <template <class...> class _Templ, class ..._Args>	511	template <template <class...> class _Templ, class ..._Args, class = _Templ<_Args...> >
513	true_type __sfinae_test_impl(_FirstType<int, _Templ<_Args...> >);	512	true_type __sfinae_test_impl(int);
514	template <template <class...> class, class ...>	513	template <template <class...> class, class ...>
515	false_type __sfinae_test_impl(...);	514	false_type __sfinae_test_impl(...);
516		515
...	@@ -526,6 +525,7 @@ struct __identity { typedef _Tp type; };	...	@@ -526,6 +525,7 @@ struct __identity { typedef _Tp type; };
526	template <class _Tp, bool>	525	template <class _Tp, bool>
527	struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {};	526	struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {};
528		527
		528
529	template <bool _Bp, class _If, class _Then>	529	template <bool _Bp, class _If, class _Then>
530	struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};	530	struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};
531	template <class _If, class _Then>	531	template <class _If, class _Then>
...	@@ -570,6 +570,17 @@ using _IsNotSame = _BoolConstant<	...	@@ -570,6 +570,17 @@ using _IsNotSame = _BoolConstant<
570	!_VSTD::is_same<_Tp, _Up>::value	570	!_VSTD::is_same<_Tp, _Up>::value
571	#endif	571	#endif
572	>;	572	>;
		573
		574
		575	template <class _Tp>
		576	using __test_for_primary_template = _EnableIf<
		577	_IsSame<_Tp, typename _Tp::__primary_template>::value
		578	>;
		579	template <class _Tp>
		580	using __is_primary_template = _IsValidExpansion<
		581	__test_for_primary_template, _Tp
		582	>;
		583
573	// addressof	584	// addressof
574	#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF	585	#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
575		586
...	@@ -720,7 +731,7 @@ template <class _Tp>	...	@@ -720,7 +731,7 @@ template <class _Tp>
720	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_null_pointer_v	731	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_null_pointer_v
721	= is_null_pointer<_Tp>::value;	732	= is_null_pointer<_Tp>::value;
722	#endif	733	#endif
723	#endif	734	#endif // _LIBCPP_STD_VER > 11
724		735
725	// is_integral	736	// is_integral
726		737
...	@@ -886,28 +897,15 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_class_v	...	@@ -886,28 +897,15 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_class_v
886		897
887	// is_function	898	// is_function
888		899
889	namespace __libcpp_is_function_imp
890	{
891	struct __dummy_type {};
892	template <class _Tp> char __test(_Tp*);
893	template <class _Tp> char __test(__dummy_type);
894	template <class _Tp> __two __test(...);
895	template <class _Tp> _Tp& __source(int);
896	template <class _Tp> __dummy_type __source(...);
897	}
898
899	template <class _Tp, bool = is_class<_Tp>::value \|\|
900	is_union<_Tp>::value \|\|
901	is_void<_Tp>::value \|\|
902	is_reference<_Tp>::value \|\|
903	__is_nullptr_t<_Tp>::value >
904	struct __libcpp_is_function
905	: public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>(0))) == 1>
906	{};
907	template <class _Tp> struct __libcpp_is_function<_Tp, true> : public false_type {};
908
909	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_function	900	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_function
910	: public __libcpp_is_function<_Tp> {};	901	: public _BoolConstant<
		902	#ifdef __clang__
		903	__is_function(_Tp)
		904	#else
		905	!(is_reference<_Tp>::value \|\| is_const<const _Tp>::value)
		906	#endif
		907	> {};
		908
911		909
912	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)	910	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
913	template <class _Tp>	911	template <class _Tp>
...	@@ -915,27 +913,24 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_function_v	...	@@ -915,27 +913,24 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_function_v
915	= is_function<_Tp>::value;	913	= is_function<_Tp>::value;
916	#endif	914	#endif
917		915
918	// is_member_function_pointer	916	template <class _Tp> struct __libcpp_is_member_pointer {
919		917	enum {
920	// template <class _Tp> struct __libcpp_is_member_function_pointer : public false_type {};	918	__is_member = false,
921	// template <class _Tp, class _Up> struct __libcpp_is_member_function_pointer<_Tp _Up::*> : public is_function<_Tp> {};	919	__is_func = false,
922	//	920	__is_obj = false
923		921	};
924	template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr>	922	};
925	struct __member_pointer_traits_imp	923	template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> {
926	{ // forward declaration; specializations later	924	enum {
		925	__is_member = true,
		926	__is_func = is_function<_Tp>::value,
		927	__is_obj = !__is_func,
		928	};
927	};	929	};
928		930
929		931
930	template <class _Tp> struct __libcpp_is_member_function_pointer
931	: public false_type {};
932
933	template <class _Ret, class _Class>
934	struct __libcpp_is_member_function_pointer<_Ret _Class::*>
935	: public is_function<_Ret> {};
936
937	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer	932	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
938	: public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type>::type {};	933	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_func > {};
939		934
940	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)	935	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
941	template <class _Tp>	936	template <class _Tp>
...	@@ -945,11 +940,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v	...	@@ -945,11 +940,8 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
945		940
946	// is_member_pointer	941	// is_member_pointer
947		942
948	template <class _Tp> struct __libcpp_is_member_pointer : public false_type {};
949	template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> : public true_type {};
950
951	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer	943	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
952	: public __libcpp_is_member_pointer<typename remove_cv<_Tp>::type> {};	944	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_member > {};
953		945
954	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)	946	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
955	template <class _Tp>	947	template <class _Tp>
...	@@ -960,8 +952,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v	...	@@ -960,8 +952,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v
960	// is_member_object_pointer	952	// is_member_object_pointer
961		953
962	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer	954	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
963	: public integral_constant<bool, is_member_pointer<_Tp>::value &&	955	: public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_obj > {};
964	!is_member_function_pointer<_Tp>::value> {};
965		956
966	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)	957	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
967	template <class _Tp>	958	template <class _Tp>
...	@@ -1080,16 +1071,9 @@ struct __is_referenceable : integral_constant<bool,	...	@@ -1080,16 +1071,9 @@ struct __is_referenceable : integral_constant<bool,
1080		1071
1081	// add_const	1072	// add_const
1082		1073
1083	template <class _Tp, bool = is_reference<_Tp>::value \|\|	1074	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const {
1084	is_function<_Tp>::value \|\|	1075	typedef _LIBCPP_NODEBUG_TYPE const _Tp type;
1085	is_const<_Tp>::value >	1076	};
1086	struct __add_const {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
1087
1088	template <class _Tp>
1089	struct __add_const<_Tp, false> {typedef _LIBCPP_NODEBUG_TYPE const _Tp type;};
1090
1091	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const
1092	{typedef _LIBCPP_NODEBUG_TYPE typename __add_const<_Tp>::type type;};
1093		1077
1094	#if _LIBCPP_STD_VER > 11	1078	#if _LIBCPP_STD_VER > 11
1095	template <class _Tp> using add_const_t = typename add_const<_Tp>::type;	1079	template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
...	@@ -1097,25 +1081,18 @@ template <class _Tp> using add_const_t = typename add_const<_Tp>::type;	...	@@ -1097,25 +1081,18 @@ template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
1097		1081
1098	// add_volatile	1082	// add_volatile
1099		1083
1100	template <class _Tp, bool = is_reference<_Tp>::value \|\|	1084	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile {
1101	is_function<_Tp>::value \|\|	1085	typedef _LIBCPP_NODEBUG_TYPE volatile _Tp type;
1102	is_volatile<_Tp>::value >	1086	};
1103	struct __add_volatile {typedef _Tp type;};
1104
1105	template <class _Tp>
1106	struct __add_volatile<_Tp, false> {typedef volatile _Tp type;};
1107
1108	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile
1109	{typedef _LIBCPP_NODEBUG_TYPE typename __add_volatile<_Tp>::type type;};
1110		1087
1111	#if _LIBCPP_STD_VER > 11	1088	#if _LIBCPP_STD_VER > 11
1112	template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;	1089	template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
1113	#endif	1090	#endif
1114		1091
1115	// add_cv	1092	// add_cv
1116		1093	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv {
1117	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv	1094	typedef _LIBCPP_NODEBUG_TYPE const volatile _Tp type;
1118	{typedef _LIBCPP_NODEBUG_TYPE typename add_const<typename add_volatile<_Tp>::type>::type type;};	1095	};
1119		1096
1120	#if _LIBCPP_STD_VER > 11	1097	#if _LIBCPP_STD_VER > 11
1121	template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;	1098	template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
...	@@ -1153,8 +1130,12 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference	...	@@ -1153,8 +1130,12 @@ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
1153	template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;	1130	template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
1154	#endif	1131	#endif
1155		1132
		1133	// Suppress deprecation notice for volatile-qualified return type resulting
		1134	// from volatile-qualified types _Tp.
		1135	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1156	template <class _Tp> _Tp&& __declval(int);	1136	template <class _Tp> _Tp&& __declval(int);
1157	template <class _Tp> _Tp __declval(long);	1137	template <class _Tp> _Tp __declval(long);
		1138	_LIBCPP_SUPPRESS_DEPRECATED_POP
1158		1139
1159	template <class _Tp>	1140	template <class _Tp>
1160	decltype(_VSTD::__declval<_Tp>(0))	1141	decltype(_VSTD::__declval<_Tp>(0))
...	@@ -1448,8 +1429,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_base_of_v	...	@@ -1448,8 +1429,7 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_base_of_v
1448	#if __has_feature(is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)	1429	#if __has_feature(is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
1449		1430
1450	template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible	1431	template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
1451	: public integral_constant<bool, __is_convertible_to(_T1, _T2) &&	1432	: public integral_constant<bool, __is_convertible_to(_T1, _T2)> {};
1452	!is_abstract<_T2>::value> {};
1453		1433
1454	#else // __has_feature(is_convertible_to)	1434	#else // __has_feature(is_convertible_to)
1455		1435
...	@@ -2307,6 +2287,11 @@ __decay_copy(_Tp&& __t)	...	@@ -2307,6 +2287,11 @@ __decay_copy(_Tp&& __t)
2307	return _VSTD::forward<_Tp>(__t);	2287	return _VSTD::forward<_Tp>(__t);
2308	}	2288	}
2309		2289
		2290	template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr>
		2291	struct __member_pointer_traits_imp
		2292	{
		2293	};
		2294
2310	template <class _Rp, class _Class, class ..._Param>	2295	template <class _Rp, class _Class, class ..._Param>
2311	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>	2296	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>
2312	{	2297	{
...	@@ -2836,6 +2821,30 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_default_constructible_v	...	@@ -2836,6 +2821,30 @@ _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_default_constructible_v
2836	= is_default_constructible<_Tp>::value;	2821	= is_default_constructible<_Tp>::value;
2837	#endif	2822	#endif
2838		2823
		2824	#ifndef _LIBCPP_CXX03_LANG
		2825	// First of all, we can't implement this check in C++03 mode because the {}
		2826	// default initialization syntax isn't valid.
		2827	// Second, we implement the trait in a funny manner with two defaulted template
		2828	// arguments to workaround Clang's PR43454.
		2829	template <class _Tp>
		2830	void __test_implicit_default_constructible(_Tp);
		2831
		2832	template <class _Tp, class = void, bool = is_default_constructible<_Tp>::value>
		2833	struct __is_implicitly_default_constructible
		2834	: false_type
		2835	{ };
		2836
		2837	template <class _Tp>
		2838	struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), true>
		2839	: true_type
		2840	{ };
		2841
		2842	template <class _Tp>
		2843	struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), false>
		2844	: false_type
		2845	{ };
		2846	#endif // !C++03
		2847
2839	// is_copy_constructible	2848	// is_copy_constructible
2840		2849
2841	template <class _Tp>	2850	template <class _Tp>
...	@@ -3681,6 +3690,13 @@ _LIBCPP_INLINE_VAR constexpr bool is_nothrow_invocable_r_v	...	@@ -3681,6 +3690,13 @@ _LIBCPP_INLINE_VAR constexpr bool is_nothrow_invocable_r_v
3681	template <class _Tp> struct __is_swappable;	3690	template <class _Tp> struct __is_swappable;
3682	template <class _Tp> struct __is_nothrow_swappable;	3691	template <class _Tp> struct __is_nothrow_swappable;
3683		3692
		3693	// swap, swap_ranges
		3694
		3695	template <class _ForwardIterator1, class _ForwardIterator2>
		3696	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
		3697	_ForwardIterator2
		3698	swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
		3699
3684	template <class _Tp>	3700	template <class _Tp>
3685	inline _LIBCPP_INLINE_VISIBILITY	3701	inline _LIBCPP_INLINE_VISIBILITY
3686	#ifndef _LIBCPP_CXX03_LANG	3702	#ifndef _LIBCPP_CXX03_LANG
...	@@ -3706,7 +3722,22 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17	...	@@ -3706,7 +3722,22 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
3706	typename enable_if<	3722	typename enable_if<
3707	__is_swappable<_Tp>::value	3723	__is_swappable<_Tp>::value
3708	>::type	3724	>::type
3709	swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);	3725	swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
		3726	{
		3727	_VSTD::swap_ranges(__a, __a + _Np, __b);
		3728	}
		3729
		3730	template <class _ForwardIterator1, class _ForwardIterator2>
		3731	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
		3732	_ForwardIterator2
		3733	swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
		3734	{
		3735	for(; __first1 != __last1; ++__first1, (void) ++__first2)
		3736	swap(__first1, __first2);
		3737	return __first2;
		3738	}
		3739
		3740	// iter_swap
3710		3741
3711	template <class _ForwardIterator1, class _ForwardIterator2>	3742	template <class _ForwardIterator1, class _ForwardIterator2>
3712	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17	3743	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
...	@@ -3985,21 +4016,6 @@ struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>	...	@@ -3985,21 +4016,6 @@ struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
3985		4016
3986	#endif	4017	#endif
3987		4018
3988	#if _LIBCPP_STD_VER > 17
3989	enum class endian
3990	{
3991	little = 0xDEAD,
3992	big = 0xFACE,
3993	#if defined(_LIBCPP_LITTLE_ENDIAN)
3994	native = little
3995	#elif defined(_LIBCPP_BIG_ENDIAN)
3996	native = big
3997	#else
3998	native = 0xCAFE
3999	#endif
4000	};
4001	#endif
4002
4003	#ifndef _LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED	4019	#ifndef _LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED
4004	#if _LIBCPP_STD_VER > 17	4020	#if _LIBCPP_STD_VER > 17
4005	_LIBCPP_INLINE_VISIBILITY	4021	_LIBCPP_INLINE_VISIBILITY

lib/libcxx/include/utility+30-33

 @@ -69,11 +69,11 @@ struct pair
     pair(const pair&) = default;
     pair(pair&&) = default;
-    constexpr pair();
+    explicit(see-below) constexpr pair();
-    pair(const T1& x, const T2& y);                          // constexpr in C++14
+    explicit(see-below) pair(const T1& x, const T2& y);                          // constexpr in C++14
-    template <class U, class V> pair(U&& x, V&& y);          // constexpr in C++14
+    template <class U, class V> explicit(see-below) pair(U&& x, V&& y);          // constexpr in C++14
-    template <class U, class V> pair(const pair<U, V>& p);   // constexpr in C++14
+    template <class U, class V> explicit(see-below) pair(const pair<U, V>& p);   // constexpr in C++14
-    template <class U, class V> pair(pair<U, V>&& p);        // constexpr in C++14
+    template <class U, class V> explicit(see-below) pair(pair<U, V>&& p);        // constexpr in C++14
     template <class... Args1, class... Args2>
         pair(piecewise_construct_t, tuple<Args1...> first_args,
              tuple<Args2...> second_args);
 @@ -99,7 +99,7 @@ template <class T1, class T2>
 void
 swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
-struct piecewise_construct_t { };
+struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 template <class T> struct tuple_size;
 @@ -248,29 +248,11 @@ operator>=(const _Tp& __x, const _Tp& __y)
 }  // rel_ops
-// swap_ranges
+// swap_ranges is defined in <type_traits>`
+// swap is defined in <type_traits>
-template <class _ForwardIterator1, class _ForwardIterator2>
+// move_if_noexcept
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-_ForwardIterator2
-swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
-{
-    for(; __first1 != __last1; ++__first1, (void) ++__first2)
-        swap(*__first1, *__first2);
-    return __first2;
-}
-// forward declared in <type_traits>
-template<class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-typename enable_if<
-    __is_swappable<_Tp>::value
->::type
-swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
-{
-    _VSTD::swap_ranges(__a, __a + _Np, __b);
-}
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 @@ -294,7 +276,7 @@ template <class _Tp> constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { r
 template <class _Tp>                        void as_const(const _Tp&&) = delete;
 #endif
-struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { };
+struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; };
 #if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY)
 extern _LIBCPP_EXPORTED_FROM_ABI const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
 #else
 @@ -352,10 +334,17 @@ struct _LIBCPP_TEMPLATE_VIS pair
     using _EnableB _LIBCPP_NODEBUG_TYPE = typename enable_if<_Val, bool>::type;
     struct _CheckArgs {
-      template <class _U1, class _U2>
+      template <int&...>
-      static constexpr bool __enable_default() {
+      static constexpr bool __enable_explicit_default() {
-          return is_default_constructible<_U1>::value
+          return is_default_constructible<_T1>::value
-              && is_default_constructible<_U2>::value;
+              && is_default_constructible<_T2>::value
+              && !__enable_implicit_default<>();
+      }
+      template <int&...>
+      static constexpr bool __enable_implicit_default() {
+          return __is_implicitly_default_constructible<_T1>::value
+              && __is_implicitly_default_constructible<_T2>::value;
       }
       template <class _U1, class _U2>
 @@ -406,7 +395,15 @@ struct _LIBCPP_TEMPLATE_VIS pair
     >::type;
     template<bool _Dummy = true, _EnableB<
-            _CheckArgsDep<_Dummy>::template __enable_default<_T1, _T2>()
+            _CheckArgsDep<_Dummy>::__enable_explicit_default()
+    > = false>
+    explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+    pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
+                      is_nothrow_default_constructible<second_type>::value)
+        : first(), second() {}
+    template<bool _Dummy = true, _EnableB<
+            _CheckArgsDep<_Dummy>::__enable_implicit_default()
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&

lib/libcxx/include/valarray+7-19

 @@ -1256,6 +1256,8 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
+    slice_array(slice_array const&) = default;
     _LIBCPP_INLINE_VISIBILITY
     const slice_array& operator=(const slice_array& __sa) const;
 @@ -1505,11 +1507,6 @@ public:
 #endif  // _LIBCPP_CXX03_LANG
-//  gslice(const gslice&)            = default;
-//  gslice(gslice&&)                 = default;
-//  gslice& operator=(const gslice&) = default;
-//  gslice& operator=(gslice&&)      = default;
     _LIBCPP_INLINE_VISIBILITY
     size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
 @@ -1645,10 +1642,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
-//  gslice_array(const gslice_array&)            = default;
+    gslice_array(const gslice_array&)            = default;
-//  gslice_array(gslice_array&&)                 = default;
-//  gslice_array& operator=(const gslice_array&) = default;
-//  gslice_array& operator=(gslice_array&&)      = default;
 private:
     gslice_array(const gslice& __gs, const valarray<value_type>& __v)
 @@ -1977,17 +1971,14 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
+    mask_array(const mask_array&) = default;
     _LIBCPP_INLINE_VISIBILITY
     const mask_array& operator=(const mask_array& __ma) const;
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
-//  mask_array(const mask_array&)            = default;
-//  mask_array(mask_array&&)                 = default;
-//  mask_array& operator=(const mask_array&) = default;
-//  mask_array& operator=(mask_array&&)      = default;
 private:
     _LIBCPP_INLINE_VISIBILITY
     mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
 @@ -2336,17 +2327,14 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
+    indirect_array(const indirect_array&) = default;
     _LIBCPP_INLINE_VISIBILITY
     const indirect_array& operator=(const indirect_array& __ia) const;
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
-//  indirect_array(const indirect_array&)            = default;
-//  indirect_array(indirect_array&&)                 = default;
-//  indirect_array& operator=(const indirect_array&) = default;
-//  indirect_array& operator=(indirect_array&&)      = default;
 private:
      _LIBCPP_INLINE_VISIBILITY
    indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)

lib/libcxx/include/vector+133-163

 @@ -297,7 +297,7 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <bool>
-class __vector_base_common
+class _LIBCPP_TEMPLATE_VIS __vector_base_common
 {
 protected:
     _LIBCPP_INLINE_VISIBILITY __vector_base_common() {}
 @@ -423,7 +423,7 @@ __vector_base<_Tp, _Allocator>::__destruct_at_end(pointer __new_last) _NOEXCEPT
 {
     pointer __soon_to_be_end = __end_;
     while (__new_last != __soon_to_be_end)
-        __alloc_traits::destroy(__alloc(), _VSTD::__to_raw_pointer(--__soon_to_be_end));
+        __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__soon_to_be_end));
     __end_ = __new_last;
 }
 @@ -433,7 +433,7 @@ __vector_base<_Tp, _Allocator>::__vector_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
       __end_(nullptr),
-      __end_cap_(nullptr)
+      __end_cap_(nullptr, __default_init_tag())
 {
 }
 @@ -518,29 +518,29 @@ public:
     vector(size_type __n, const value_type& __x, const allocator_type& __a);
     template <class _InputIterator>
         vector(_InputIterator __first,
-               typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+               typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                                 !__is_forward_iterator<_InputIterator>::value &&
+                                 !__is_cpp17_forward_iterator<_InputIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_InputIterator>::reference>::value,
                                  _InputIterator>::type __last);
     template <class _InputIterator>
         vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
-               typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+               typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                                 !__is_forward_iterator<_InputIterator>::value &&
+                                 !__is_cpp17_forward_iterator<_InputIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_InputIterator>::reference>::value>::type* = 0);
     template <class _ForwardIterator>
         vector(_ForwardIterator __first,
-               typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
+               typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_ForwardIterator>::reference>::value,
                                  _ForwardIterator>::type __last);
     template <class _ForwardIterator>
         vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
-               typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
+               typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                  is_constructible<
                                     value_type,
                                     typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0);
 @@ -589,8 +589,8 @@ public:
     template <class _InputIterator>
         typename enable_if
         <
-             __is_input_iterator  <_InputIterator>::value &&
+             __is_cpp17_input_iterator  <_InputIterator>::value &&
-            !__is_forward_iterator<_InputIterator>::value &&
+            !__is_cpp17_forward_iterator<_InputIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_InputIterator>::reference>::value,
 @@ -600,7 +600,7 @@ public:
     template <class _ForwardIterator>
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value &&
+            __is_cpp17_forward_iterator<_ForwardIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_ForwardIterator>::reference>::value,
 @@ -692,10 +692,10 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     value_type*       data() _NOEXCEPT
-        {return _VSTD::__to_raw_pointer(this->__begin_);}
+        {return _VSTD::__to_address(this->__begin_);}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* data() const _NOEXCEPT
-        {return _VSTD::__to_raw_pointer(this->__begin_);}
+        {return _VSTD::__to_address(this->__begin_);}
 #ifdef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
 @@ -737,8 +737,8 @@ public:
     template <class _InputIterator>
         typename enable_if
         <
-             __is_input_iterator  <_InputIterator>::value &&
+             __is_cpp17_input_iterator  <_InputIterator>::value &&
-            !__is_forward_iterator<_InputIterator>::value &&
+            !__is_cpp17_forward_iterator<_InputIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_InputIterator>::reference>::value,
 @@ -748,7 +748,7 @@ public:
     template <class _ForwardIterator>
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value &&
+            __is_cpp17_forward_iterator<_ForwardIterator>::value &&
             is_constructible<
                  value_type,
                  typename iterator_traits<_ForwardIterator>::reference>::value,
 @@ -808,7 +808,7 @@ private:
     template <class _ForwardIterator>
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value,
+            __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n);
 @@ -864,58 +864,67 @@ private:
 #else
     _LIBCPP_INLINE_VISIBILITY
     void __annotate_contiguous_container(const void*, const void*, const void*,
-                                         const void*) const {}
+                                         const void*) const _NOEXCEPT {}
 #endif
     _LIBCPP_INLINE_VISIBILITY
-    void __annotate_new(size_type __current_size) const {
+    void __annotate_new(size_type __current_size) const _NOEXCEPT {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + capacity(), data() + __current_size);
     }
     _LIBCPP_INLINE_VISIBILITY
-    void __annotate_delete() const {
+    void __annotate_delete() const _NOEXCEPT {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + size(), data() + capacity());
     }
     _LIBCPP_INLINE_VISIBILITY
-    void __annotate_increase(size_type __n) const
+    void __annotate_increase(size_type __n) const _NOEXCEPT
     {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + size(), data() + size() + __n);
     }
     _LIBCPP_INLINE_VISIBILITY
-    void __annotate_shrink(size_type __old_size) const
+    void __annotate_shrink(size_type __old_size) const _NOEXCEPT
     {
       __annotate_contiguous_container(data(), data() + capacity(),
                                       data() + __old_size, data() + size());
     }
+  struct _ConstructTransaction {
+    explicit _ConstructTransaction(vector &__v, size_type __n)
+      : __v_(__v),  __pos_(__v.__end_), __new_end_(__v.__end_ + __n) {
 #ifndef _LIBCPP_HAS_NO_ASAN
-    // The annotation for size increase should happen before the actual increase,
+      __v_.__annotate_increase(__n);
-    // but if an exception is thrown after that the annotation has to be undone.
+#endif
-    struct __RAII_IncreaseAnnotator {
+    }
-      __RAII_IncreaseAnnotator(const vector &__v, size_type __n = 1)
+    ~_ConstructTransaction() {
-        : __commit(false), __v(__v), __old_size(__v.size() + __n) {
+      __v_.__end_ = __pos_;
-        __v.__annotate_increase(__n);
+#ifndef _LIBCPP_HAS_NO_ASAN
-      }
+      if (__pos_ != __new_end_) {
-      void __done() { __commit = true; }
+        __v_.__annotate_shrink(__new_end_ - __v_.__begin_);
-      ~__RAII_IncreaseAnnotator() {
-        if (__commit) return;
-        __v.__annotate_shrink(__old_size);
       }
-      bool __commit;
-      const vector &__v;
-      size_type __old_size;
-    };
-#else
-    struct __RAII_IncreaseAnnotator {
-      _LIBCPP_INLINE_VISIBILITY
-      __RAII_IncreaseAnnotator(const vector &, size_type = 1) {}
-      _LIBCPP_INLINE_VISIBILITY void __done() {}
-    };
 #endif
+    }
+    vector &__v_;
+    pointer __pos_;
+    const_pointer const __new_end_;
+  private:
+    _ConstructTransaction(_ConstructTransaction const&) = delete;
+    _ConstructTransaction& operator=(_ConstructTransaction const&) = delete;
+  };
+  template <class ..._Args>
+  _LIBCPP_INLINE_VISIBILITY
+  void __construct_one_at_end(_Args&& ...__args) {
+    _ConstructTransaction __tx(*this, 1);
+    __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_),
+        _VSTD::forward<_Args>(__args)...);
+    ++__tx.__pos_;
+  }
 };
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 @@ -938,8 +947,10 @@ template <class _Tp, class _Allocator>
 void
 vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v)
 {
     __annotate_delete();
-    __alloc_traits::__construct_backward(this->__alloc(), this->__begin_, this->__end_, __v.__begin_);
+    __alloc_traits::__construct_backward_with_exception_guarantees(
+        this->__alloc(), this->__begin_, this->__end_, __v.__begin_);
     _VSTD::swap(this->__begin_, __v.__begin_);
     _VSTD::swap(this->__end_, __v.__end_);
     _VSTD::swap(this->__end_cap(), __v.__end_cap());
 @@ -954,8 +965,10 @@ vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, a
 {
     __annotate_delete();
     pointer __r = __v.__begin_;
-    __alloc_traits::__construct_backward(this->__alloc(), this->__begin_, __p, __v.__begin_);
+    __alloc_traits::__construct_backward_with_exception_guarantees(
-    __alloc_traits::__construct_forward(this->__alloc(), __p, this->__end_, __v.__end_);
+        this->__alloc(), this->__begin_, __p, __v.__begin_);
+    __alloc_traits::__construct_forward_with_exception_guarantees(
+        this->__alloc(), __p, this->__end_, __v.__end_);
     _VSTD::swap(this->__begin_, __v.__begin_);
     _VSTD::swap(this->__end_, __v.__end_);
     _VSTD::swap(this->__end_cap(), __v.__end_cap());
 @@ -1027,15 +1040,10 @@ template <class _Tp, class _Allocator>
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
 {
-    allocator_type& __a = this->__alloc();
+    _ConstructTransaction __tx(*this, __n);
-    do
+    for (; __tx.__pos_ != __tx.__new_end_; ++__tx.__pos_) {
-    {
+      __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_));
-        __RAII_IncreaseAnnotator __annotator(*this);
+    }
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
-        ++this->__end_;
-        --__n;
-        __annotator.__done();
-    } while (__n > 0);
 }
 //  Copy constructs __n objects starting at __end_ from __x
 @@ -1049,30 +1057,23 @@ inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
-    allocator_type& __a = this->__alloc();
+    _ConstructTransaction __tx(*this, __n);
-    do
+    for (; __tx.__pos_ != __tx.__new_end_; ++__tx.__pos_) {
-    {
+        __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_), __x);
-        __RAII_IncreaseAnnotator __annotator(*this);
+    }
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
-        ++this->__end_;
-        --__n;
-        __annotator.__done();
-    } while (__n > 0);
 }
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
-    __is_forward_iterator<_ForwardIterator>::value,
+    __is_cpp17_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n)
 {
-    allocator_type& __a = this->__alloc();
+    _ConstructTransaction __tx(*this, __n);
-    __RAII_IncreaseAnnotator __annotator(*this, __n);
+    __alloc_traits::__construct_range_forward(this->__alloc(), __first, __last, __tx.__pos_);
-    __alloc_traits::__construct_range_forward(__a, __first, __last, this->__end_);
-    __annotator.__done();
 }
 //  Default constructs __n objects starting at __end_
 @@ -1172,8 +1173,8 @@ vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x, const allo
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
 vector<_Tp, _Allocator>::vector(_InputIterator __first,
-       typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+       typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                         !__is_forward_iterator<_InputIterator>::value &&
+                         !__is_cpp17_forward_iterator<_InputIterator>::value &&
                          is_constructible<
                             value_type,
                             typename iterator_traits<_InputIterator>::reference>::value,
 @@ -1189,8 +1190,8 @@ vector<_Tp, _Allocator>::vector(_InputIterator __first,
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
 vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
-       typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+       typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                         !__is_forward_iterator<_InputIterator>::value &&
+                         !__is_cpp17_forward_iterator<_InputIterator>::value &&
                          is_constructible<
                             value_type,
                             typename iterator_traits<_InputIterator>::reference>::value>::type*)
 @@ -1206,7 +1207,7 @@ vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, c
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first,
-                                typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
+                                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                 is_constructible<
                                    value_type,
                                    typename iterator_traits<_ForwardIterator>::reference>::value,
 @@ -1226,7 +1227,7 @@ vector<_Tp, _Allocator>::vector(_ForwardIterator __first,
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
-                                typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
+                                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
                                 is_constructible<
                                    value_type,
                                    typename iterator_traits<_ForwardIterator>::reference>::value>::type*)
 @@ -1409,8 +1410,8 @@ template <class _Tp, class _Allocator>
 template <class _InputIterator>
 typename enable_if
 <
-     __is_input_iterator  <_InputIterator>::value &&
+     __is_cpp17_input_iterator  <_InputIterator>::value &&
-    !__is_forward_iterator<_InputIterator>::value &&
+    !__is_cpp17_forward_iterator<_InputIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_InputIterator>::reference>::value,
 @@ -1427,7 +1428,7 @@ template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
-    __is_forward_iterator<_ForwardIterator>::value &&
+    __is_cpp17_forward_iterator<_ForwardIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_ForwardIterator>::reference>::value,
 @@ -1621,7 +1622,7 @@ vector<_Tp, _Allocator>::__push_back_slow_path(_Up& __x)
     allocator_type& __a = this->__alloc();
     __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
     // __v.push_back(_VSTD::forward<_Up>(__x));
-    __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Up>(__x));
+    __alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Up>(__x));
     __v.__end_++;
     __swap_out_circular_buffer(__v);
 }
 @@ -1633,11 +1634,7 @@ vector<_Tp, _Allocator>::push_back(const_reference __x)
 {
     if (this->__end_ != this->__end_cap())
     {
-        __RAII_IncreaseAnnotator __annotator(*this);
+        __construct_one_at_end(__x);
-        __alloc_traits::construct(this->__alloc(),
-                                  _VSTD::__to_raw_pointer(this->__end_), __x);
-        __annotator.__done();
-        ++this->__end_;
     }
     else
         __push_back_slow_path(__x);
 @@ -1652,12 +1649,7 @@ vector<_Tp, _Allocator>::push_back(value_type&& __x)
 {
     if (this->__end_ < this->__end_cap())
     {
-        __RAII_IncreaseAnnotator __annotator(*this);
+        __construct_one_at_end(_VSTD::move(__x));
-        __alloc_traits::construct(this->__alloc(),
-                                  _VSTD::__to_raw_pointer(this->__end_),
-                                  _VSTD::move(__x));
-        __annotator.__done();
-        ++this->__end_;
     }
     else
         __push_back_slow_path(_VSTD::move(__x));
 @@ -1671,7 +1663,7 @@ vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args)
     allocator_type& __a = this->__alloc();
     __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
 //    __v.emplace_back(_VSTD::forward<_Args>(__args)...);
-    __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Args>(__args)...);
     __v.__end_++;
     __swap_out_circular_buffer(__v);
 }
 @@ -1688,12 +1680,7 @@ vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 {
     if (this->__end_ < this->__end_cap())
     {
-        __RAII_IncreaseAnnotator __annotator(*this);
+        __construct_one_at_end(_VSTD::forward<_Args>(__args)...);
-        __alloc_traits::construct(this->__alloc(),
-                                  _VSTD::__to_raw_pointer(this->__end_),
-                                  _VSTD::forward<_Args>(__args)...);
-        __annotator.__done();
-        ++this->__end_;
     }
     else
         __emplace_back_slow_path(_VSTD::forward<_Args>(__args)...);
 @@ -1761,10 +1748,15 @@ vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointe
 {
     pointer __old_last = this->__end_;
     difference_type __n = __old_last - __to;
-    for (pointer __i = __from_s + __n; __i < __from_e; ++__i, ++this->__end_)
+    {
-        __alloc_traits::construct(this->__alloc(),
+      pointer __i = __from_s + __n;
-                                  _VSTD::__to_raw_pointer(this->__end_),
+      _ConstructTransaction __tx(*this, __from_e - __i);
-                                  _VSTD::move(*__i));
+      for (; __i < __from_e; ++__i, ++__tx.__pos_) {
+          __alloc_traits::construct(this->__alloc(),
+                                    _VSTD::__to_address(__tx.__pos_),
+                                    _VSTD::move(*__i));
+      }
+    }
     _VSTD::move_backward(__from_s, __from_s + __n, __old_last);
 }
 @@ -1780,12 +1772,9 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
     pointer __p = this->__begin_ + (__position - begin());
     if (this->__end_ < this->__end_cap())
     {
-        __RAII_IncreaseAnnotator __annotator(*this);
         if (__p == this->__end_)
         {
-            __alloc_traits::construct(this->__alloc(),
+            __construct_one_at_end(__x);
-                                      _VSTD::__to_raw_pointer(this->__end_), __x);
-            ++this->__end_;
         }
         else
         {
 @@ -1795,7 +1784,6 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
                 ++__xr;
             *__p = *__xr;
         }
-        __annotator.__done();
     }
     else
     {
 @@ -1821,20 +1809,15 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
     pointer __p = this->__begin_ + (__position - begin());
     if (this->__end_ < this->__end_cap())
     {
-        __RAII_IncreaseAnnotator __annotator(*this);
         if (__p == this->__end_)
         {
-            __alloc_traits::construct(this->__alloc(),
+            __construct_one_at_end(_VSTD::move(__x));
-                                      _VSTD::__to_raw_pointer(this->__end_),
-                                      _VSTD::move(__x));
-            ++this->__end_;
         }
         else
         {
             __move_range(__p, this->__end_, __p + 1);
             *__p = _VSTD::move(__x);
         }
-        __annotator.__done();
     }
     else
     {
 @@ -1859,13 +1842,9 @@ vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
     pointer __p = this->__begin_ + (__position - begin());
     if (this->__end_ < this->__end_cap())
     {
-        __RAII_IncreaseAnnotator __annotator(*this);
         if (__p == this->__end_)
         {
-            __alloc_traits::construct(this->__alloc(),
+            __construct_one_at_end(_VSTD::forward<_Args>(__args)...);
-                                      _VSTD::__to_raw_pointer(this->__end_),
-                                      _VSTD::forward<_Args>(__args)...);
-            ++this->__end_;
         }
         else
         {
 @@ -1873,7 +1852,6 @@ vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
             __move_range(__p, this->__end_, __p + 1);
             *__p = _VSTD::move(__tmp.get());
         }
-        __annotator.__done();
     }
     else
     {
 @@ -1911,9 +1889,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_
             }
             if (__n > 0)
             {
-                __RAII_IncreaseAnnotator __annotator(*this, __n);
                 __move_range(__p, __old_last, __p + __old_n);
-                __annotator.__done();
                 const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
                 if (__p <= __xr && __xr < this->__end_)
                     __xr += __old_n;
 @@ -1935,8 +1911,8 @@ template <class _Tp, class _Allocator>
 template <class _InputIterator>
 typename enable_if
 <
-     __is_input_iterator  <_InputIterator>::value &&
+     __is_cpp17_input_iterator  <_InputIterator>::value &&
-    !__is_forward_iterator<_InputIterator>::value &&
+    !__is_cpp17_forward_iterator<_InputIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_InputIterator>::reference>::value,
 @@ -1955,11 +1931,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __firs
     pointer __old_last = this->__end_;
     for (; this->__end_ != this->__end_cap() && __first != __last; ++__first)
     {
-        __RAII_IncreaseAnnotator __annotator(*this);
+        __construct_one_at_end(*__first);
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_),
-                                  *__first);
-        ++this->__end_;
-        __annotator.__done();
     }
     __split_buffer<value_type, allocator_type&> __v(__a);
     if (__first != __last)
 @@ -1993,7 +1965,7 @@ template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
-    __is_forward_iterator<_ForwardIterator>::value &&
+    __is_cpp17_forward_iterator<_ForwardIterator>::value &&
     is_constructible<
        _Tp,
        typename iterator_traits<_ForwardIterator>::reference>::value,
 @@ -2026,9 +1998,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __fi
             }
             if (__n > 0)
             {
-                __RAII_IncreaseAnnotator __annotator(*this, __n);
                 __move_range(__p, __old_last, __p + __old_n);
-                __annotator.__done();
                 _VSTD::copy(__first, __m, __p);
             }
         }
 @@ -2261,18 +2231,18 @@ public:
     vector(size_type __n, const value_type& __v, const allocator_type& __a);
     template <class _InputIterator>
         vector(_InputIterator __first, _InputIterator __last,
-               typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+               typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                                 !__is_forward_iterator<_InputIterator>::value>::type* = 0);
+                                 !__is_cpp17_forward_iterator<_InputIterator>::value>::type* = 0);
     template <class _InputIterator>
         vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
-               typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+               typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                                 !__is_forward_iterator<_InputIterator>::value>::type* = 0);
+                                 !__is_cpp17_forward_iterator<_InputIterator>::value>::type* = 0);
     template <class _ForwardIterator>
         vector(_ForwardIterator __first, _ForwardIterator __last,
-               typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0);
+               typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
     template <class _ForwardIterator>
         vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
-               typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0);
+               typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type* = 0);
     vector(const vector& __v);
     vector(const vector& __v, const allocator_type& __a);
 @@ -2303,15 +2273,15 @@ public:
     template <class _InputIterator>
         typename enable_if
         <
-            __is_input_iterator<_InputIterator>::value &&
+            __is_cpp17_input_iterator<_InputIterator>::value &&
-           !__is_forward_iterator<_InputIterator>::value,
+           !__is_cpp17_forward_iterator<_InputIterator>::value,
            void
         >::type
         assign(_InputIterator __first, _InputIterator __last);
     template <class _ForwardIterator>
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value,
+            __is_cpp17_forward_iterator<_ForwardIterator>::value,
            void
         >::type
         assign(_ForwardIterator __first, _ForwardIterator __last);
 @@ -2419,15 +2389,15 @@ public:
     template <class _InputIterator>
         typename enable_if
         <
-             __is_input_iterator  <_InputIterator>::value &&
+             __is_cpp17_input_iterator  <_InputIterator>::value &&
-            !__is_forward_iterator<_InputIterator>::value,
+            !__is_cpp17_forward_iterator<_InputIterator>::value,
             iterator
         >::type
         insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
     template <class _ForwardIterator>
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value,
+            __is_cpp17_forward_iterator<_ForwardIterator>::value,
             iterator
         >::type
         insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 @@ -2470,7 +2440,7 @@ private:
     template <class _ForwardIterator>
         typename enable_if
         <
-            __is_forward_iterator<_ForwardIterator>::value,
+            __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 @@ -2629,7 +2599,7 @@ template <class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
-    __is_forward_iterator<_ForwardIterator>::value,
+    __is_cpp17_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
 @@ -2652,7 +2622,7 @@ vector<bool, _Allocator>::vector()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __begin_(nullptr),
       __size_(0),
-      __cap_alloc_(0)
+      __cap_alloc_(0, __default_init_tag())
 {
 }
 @@ -2674,7 +2644,7 @@ template <class _Allocator>
 vector<bool, _Allocator>::vector(size_type __n)
     : __begin_(nullptr),
       __size_(0),
-      __cap_alloc_(0)
+      __cap_alloc_(0, __default_init_tag())
 {
     if (__n > 0)
     {
 @@ -2702,7 +2672,7 @@ template <class _Allocator>
 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
     : __begin_(nullptr),
       __size_(0),
-      __cap_alloc_(0)
+      __cap_alloc_(0, __default_init_tag())
 {
     if (__n > 0)
     {
 @@ -2727,11 +2697,11 @@ vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const all
 template <class _Allocator>
 template <class _InputIterator>
 vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
-       typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+       typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                         !__is_forward_iterator<_InputIterator>::value>::type*)
+                         !__is_cpp17_forward_iterator<_InputIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
-      __cap_alloc_(0)
+      __cap_alloc_(0, __default_init_tag())
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
 @@ -2754,8 +2724,8 @@ vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
 template <class _Allocator>
 template <class _InputIterator>
 vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
-       typename enable_if<__is_input_iterator  <_InputIterator>::value &&
+       typename enable_if<__is_cpp17_input_iterator  <_InputIterator>::value &&
-                         !__is_forward_iterator<_InputIterator>::value>::type*)
+                         !__is_cpp17_forward_iterator<_InputIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 @@ -2781,10 +2751,10 @@ vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
 template <class _Allocator>
 template <class _ForwardIterator>
 vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
-                                typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
+                                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
-      __cap_alloc_(0)
+      __cap_alloc_(0, __default_init_tag())
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
 @@ -2797,7 +2767,7 @@ vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __la
 template <class _Allocator>
 template <class _ForwardIterator>
 vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
-                                typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
+                                typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
     : __begin_(nullptr),
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 @@ -2816,7 +2786,7 @@ template <class _Allocator>
 vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
     : __begin_(nullptr),
       __size_(0),
-      __cap_alloc_(0)
+      __cap_alloc_(0, __default_init_tag())
 {
     size_type __n = static_cast<size_type>(__il.size());
     if (__n > 0)
 @@ -2998,8 +2968,8 @@ template <class _Allocator>
 template <class _InputIterator>
 typename enable_if
 <
-    __is_input_iterator<_InputIterator>::value &&
+    __is_cpp17_input_iterator<_InputIterator>::value &&
-   !__is_forward_iterator<_InputIterator>::value,
+   !__is_cpp17_forward_iterator<_InputIterator>::value,
    void
 >::type
 vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 @@ -3013,7 +2983,7 @@ template <class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
-    __is_forward_iterator<_ForwardIterator>::value,
+    __is_cpp17_forward_iterator<_ForwardIterator>::value,
    void
 >::type
 vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 @@ -3150,8 +3120,8 @@ template <class _Allocator>
 template <class _InputIterator>
 typename enable_if
 <
-     __is_input_iterator  <_InputIterator>::value &&
+     __is_cpp17_input_iterator  <_InputIterator>::value &&
-    !__is_forward_iterator<_InputIterator>::value,
+    !__is_cpp17_forward_iterator<_InputIterator>::value,
     typename vector<bool, _Allocator>::iterator
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
 @@ -3195,7 +3165,7 @@ template <class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
-    __is_forward_iterator<_ForwardIterator>::value,
+    __is_cpp17_forward_iterator<_ForwardIterator>::value,
     typename vector<bool, _Allocator>::iterator
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)

lib/libcxx/include/version+2

author	Andrew Kelley <andrew@ziglang.org> 2020-02-14 10:34:21-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-02-14 10:34:21-05:00
log	2289036a40082eb5316e2a46fb2f3a78a8be0c7d
tree	9ddbafeeec6b9166667f82f0334e74a7b97fcf2b
parent	74619cc04586866013e40228f001e3fa79932d8e
signature	Commit is signed but in an unrecognized format.

...	@@ -104,7 +104,7 @@ class __func<_Fp, _Alloc, _Rp()>	...	@@ -104,7 +104,7 @@ class __func<_Fp, _Alloc, _Rp()>
104	{	104	{
105	__compressed_pair<_Fp, _Alloc> __f_;	105	__compressed_pair<_Fp, _Alloc> __f_;
106	public:	106	public:
107	explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}	107	explicit __func(_Fp __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
108	explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}	108	explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
109	virtual __base<_Rp()>* __clone() const;	109	virtual __base<_Rp()>* __clone() const;
110	virtual void __clone(__base<_Rp()>*) const;	110	virtual void __clone(__base<_Rp()>*) const;
...	@@ -189,7 +189,7 @@ class __func<_Fp, _Alloc, _Rp(_A0)>	...	@@ -189,7 +189,7 @@ class __func<_Fp, _Alloc, _Rp(_A0)>
189	{	189	{
190	__compressed_pair<_Fp, _Alloc> __f_;	190	__compressed_pair<_Fp, _Alloc> __f_;
191	public:	191	public:
192	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}	192	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
193	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)	193	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)
194	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}	194	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
195	virtual __base<_Rp(_A0)>* __clone() const;	195	virtual __base<_Rp(_A0)>* __clone() const;
...	@@ -275,7 +275,7 @@ class __func<_Fp, _Alloc, _Rp(_A0, _A1)>	...	@@ -275,7 +275,7 @@ class __func<_Fp, _Alloc, _Rp(_A0, _A1)>
275	{	275	{
276	__compressed_pair<_Fp, _Alloc> __f_;	276	__compressed_pair<_Fp, _Alloc> __f_;
277	public:	277	public:
278	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}	278	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
279	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)	279	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)
280	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}	280	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
281	virtual __base<_Rp(_A0, _A1)>* __clone() const;	281	virtual __base<_Rp(_A0, _A1)>* __clone() const;
...	@@ -361,7 +361,7 @@ class __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>	...	@@ -361,7 +361,7 @@ class __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>
361	{	361	{
362	__compressed_pair<_Fp, _Alloc> __f_;	362	__compressed_pair<_Fp, _Alloc> __f_;
363	public:	363	public:
364	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}	364	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
365	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)	365	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)
366	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}	366	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
367	virtual __base<_Rp(_A0, _A1, _A2)>* __clone() const;	367	virtual __base<_Rp(_A0, _A1, _A2)>* __clone() const;

...	@@ -775,11 +775,14 @@ private:	...	@@ -775,11 +775,14 @@ private:
775	typedef __tree_node_types<pointer> _NodeTypes;	775	typedef __tree_node_types<pointer> _NodeTypes;
776	allocator_type& __na_;	776	allocator_type& __na_;
777		777
778	__tree_node_destructor& operator=(const __tree_node_destructor&);
779		778
780	public:	779	public:
781	bool __value_constructed;	780	bool __value_constructed;
782		781
		782
		783	__tree_node_destructor(const __tree_node_destructor &) = default;
		784	__tree_node_destructor& operator=(const __tree_node_destructor&) = delete;
		785
783	_LIBCPP_INLINE_VISIBILITY	786	_LIBCPP_INLINE_VISIBILITY
784	explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT	787	explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
785	: __na_(__na),	788	: __na_(__na),
...	@@ -1574,8 +1577,8 @@ __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)	...	@@ -1574,8 +1577,8 @@ __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
1574	template <class _Tp, class _Compare, class _Allocator>	1577	template <class _Tp, class _Compare, class _Allocator>
1575	__tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)	1578	__tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)
1576	: __begin_node_(__iter_pointer()),	1579	: __begin_node_(__iter_pointer()),
1577	__pair1_(__second_tag(), __node_allocator(__a)),	1580	__pair1_(__default_init_tag(), __node_allocator(__a)),
1578	__pair3_(0)	1581	__pair3_(0, __default_init_tag())
1579	{	1582	{
1580	__begin_node() = __end_node();	1583	__begin_node() = __end_node();
1581	}	1584	}
...	@@ -1584,7 +1587,7 @@ template <class _Tp, class _Compare, class _Allocator>	...	@@ -1584,7 +1587,7 @@ template <class _Tp, class _Compare, class _Allocator>
1584	__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp,	1587	__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp,
1585	const allocator_type& __a)	1588	const allocator_type& __a)
1586	: __begin_node_(__iter_pointer()),	1589	: __begin_node_(__iter_pointer()),
1587	__pair1_(__second_tag(), __node_allocator(__a)),	1590	__pair1_(__default_init_tag(), __node_allocator(__a)),
1588	__pair3_(0, __comp)	1591	__pair3_(0, __comp)
1589	{	1592	{
1590	__begin_node() = __end_node();	1593	__begin_node() = __end_node();
...	@@ -1656,7 +1659,7 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_ForwardIterator __first, _Fo	...	@@ -1656,7 +1659,7 @@ __tree<_Tp, _Compare, _Allocator>::__assign_unique(_ForwardIterator __first, _Fo
1656	typedef typename _ITraits::value_type _ItValueType;	1659	typedef typename _ITraits::value_type _ItValueType;
1657	static_assert((is_same<_ItValueType, __container_value_type>::value),	1660	static_assert((is_same<_ItValueType, __container_value_type>::value),
1658	"__assign_unique may only be called with the containers value type");	1661	"__assign_unique may only be called with the containers value type");
1659	static_assert(__is_forward_iterator<_ForwardIterator>::value,	1662	static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
1660	"__assign_unique requires a forward iterator");	1663	"__assign_unique requires a forward iterator");
1661	if (size() != 0)	1664	if (size() != 0)
1662	{	1665	{
...	@@ -1697,7 +1700,7 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input	...	@@ -1697,7 +1700,7 @@ __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _Input
1697	template <class _Tp, class _Compare, class _Allocator>	1700	template <class _Tp, class _Compare, class _Allocator>
1698	__tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)	1701	__tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
1699	: __begin_node_(__iter_pointer()),	1702	: __begin_node_(__iter_pointer()),
1700	__pair1_(__second_tag(), __node_traits::select_on_container_copy_construction(__t.__node_alloc())),	1703	__pair1_(__default_init_tag(), __node_traits::select_on_container_copy_construction(__t.__node_alloc())),
1701	__pair3_(0, __t.value_comp())	1704	__pair3_(0, __t.value_comp())
1702	{	1705	{
1703	__begin_node() = __end_node();	1706	__begin_node() = __end_node();
...	@@ -1727,7 +1730,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)	...	@@ -1727,7 +1730,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
1727		1730
1728	template <class _Tp, class _Compare, class _Allocator>	1731	template <class _Tp, class _Compare, class _Allocator>
1729	__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)	1732	__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
1730	: __pair1_(__second_tag(), __node_allocator(__a)),	1733	: __pair1_(__default_init_tag(), __node_allocator(__a)),
1731	__pair3_(0, _VSTD::move(__t.value_comp()))	1734	__pair3_(0, _VSTD::move(__t.value_comp()))
1732	{	1735	{
1733	if (__a == __t.__alloc())	1736	if (__a == __t.__alloc())

...	@@ -112,7 +112,7 @@ template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>	...	@@ -112,7 +112,7 @@ template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
112	class _LIBCPP_TYPE_VIS default_searcher {	112	class _LIBCPP_TYPE_VIS default_searcher {
113	public:	113	public:
114	_LIBCPP_INLINE_VISIBILITY	114	_LIBCPP_INLINE_VISIBILITY
115	default_searcher(_ForwardIterator __f, _ForwardIterator __l,	115	default_searcher(_ForwardIterator __f, _ForwardIterator __l,
116	_BinaryPredicate __p = _BinaryPredicate())	116	_BinaryPredicate __p = _BinaryPredicate())
117	: __first_(__f), __last_(__l), __pred_(__p) {}	117	: __first_(__f), __last_(__l), __pred_(__p) {}
118		118
...	@@ -151,12 +151,12 @@ public: // TODO private:	...	@@ -151,12 +151,12 @@ public: // TODO private:
151		151
152	const _Value __default_value_;	152	const _Value __default_value_;
153	std::unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table;	153	std::unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table;
154		154
155	public:	155	public:
156	_LIBCPP_INLINE_VISIBILITY	156	_LIBCPP_INLINE_VISIBILITY
157	_BMSkipTable(std::size_t __sz, _Value __default, _Hash __hf, _BinaryPredicate __pred)	157	_BMSkipTable(std::size_t __sz, _Value __default, _Hash __hf, _BinaryPredicate __pred)
158	: __default_value_(__default), __table(__sz, __hf, __pred) {}	158	: __default_value_(__default), __table(__sz, __hf, __pred) {}
159		159
160	_LIBCPP_INLINE_VISIBILITY	160	_LIBCPP_INLINE_VISIBILITY
161	void insert(const key_type &__key, value_type __val)	161	void insert(const key_type &__key, value_type __val)
162	{	162	{
...	@@ -170,7 +170,7 @@ public:	...	@@ -170,7 +170,7 @@ public:
170	return __it == __table.end() ? __default_value_ : __it->second;	170	return __it == __table.end() ? __default_value_ : __it->second;
171	}	171	}
172	};	172	};
173		173
174		174
175	// Special case small numeric values; use an array	175	// Special case small numeric values; use an array
176	template<class _Key, typename _Value, class _Hash, class _BinaryPredicate>	176	template<class _Key, typename _Value, class _Hash, class _BinaryPredicate>
...	@@ -189,7 +189,7 @@ public:	...	@@ -189,7 +189,7 @@ public:
189	{	189	{
190	std::fill_n(__table.begin(), __table.size(), __default);	190	std::fill_n(__table.begin(), __table.size(), __default);
191	}	191	}
192		192
193	_LIBCPP_INLINE_VISIBILITY	193	_LIBCPP_INLINE_VISIBILITY
194	void insert(key_type __key, value_type __val)	194	void insert(key_type __key, value_type __val)
195	{	195	{
...	@@ -204,8 +204,8 @@ public:	...	@@ -204,8 +204,8 @@ public:
204	};	204	};
205		205
206		206
207	template <class _RandomAccessIterator1,	207	template <class _RandomAccessIterator1,
208	class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,	208	class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
209	class _BinaryPredicate = equal_to<>>	209	class _BinaryPredicate = equal_to<>>
210	class _LIBCPP_TYPE_VIS boyer_moore_searcher {	210	class _LIBCPP_TYPE_VIS boyer_moore_searcher {
211	private:	211	private:
...	@@ -217,9 +217,9 @@ private:	...	@@ -217,9 +217,9 @@ private:
217	is_same<_Hash, hash<value_type>>::value &&	217	is_same<_Hash, hash<value_type>>::value &&
218	is_same<_BinaryPredicate, equal_to<>>::value	218	is_same<_BinaryPredicate, equal_to<>>::value
219	> skip_table_type;	219	> skip_table_type;
220		220
221	public:	221	public:
222	boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,	222	boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,
223	_Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())	223	_Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())
224	: __first_(__f), __last_(__l), __pred_(__pred),	224	: __first_(__f), __last_(__l), __pred_(__pred),
225	__pattern_length_(_VSTD::distance(__first_, __last_)),	225	__pattern_length_(_VSTD::distance(__first_, __last_)),
...	@@ -232,13 +232,13 @@ public:	...	@@ -232,13 +232,13 @@ public:
232		232
233	this->__build_suffix_table ( __first_, __last_, __pred_ );	233	this->__build_suffix_table ( __first_, __last_, __pred_ );
234	}	234	}
235		235
236	template <typename _RandomAccessIterator2>	236	template <typename _RandomAccessIterator2>
237	pair<_RandomAccessIterator2, _RandomAccessIterator2>	237	pair<_RandomAccessIterator2, _RandomAccessIterator2>
238	operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const	238	operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
239	{	239	{
240	static_assert ( std::is_same<	240	static_assert ( std::is_same<
241	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,	241	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,
242	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type	242	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type
243	>::value,	243	>::value,
244	"Corpus and Pattern iterators must point to the same type" );	244	"Corpus and Pattern iterators must point to the same type" );
...	@@ -247,13 +247,13 @@ public:	...	@@ -247,13 +247,13 @@ public:
247	if (__first_ == __last_) return make_pair(__f, __f); // empty pattern	247	if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
248		248
249	// If the pattern is larger than the corpus, we can't find it!	249	// If the pattern is larger than the corpus, we can't find it!
250	if ( __pattern_length_ > _VSTD::distance (__f, __l))	250	if ( __pattern_length_ > _VSTD::distance (__f, __l))
251	return make_pair(__l, __l);	251	return make_pair(__l, __l);
252		252
253	// Do the search	253	// Do the search
254	return this->__search(__f, __l);	254	return this->__search(__f, __l);
255	}	255	}
256		256
257	public: // TODO private:	257	public: // TODO private:
258	_RandomAccessIterator1 __first_;	258	_RandomAccessIterator1 __first_;
259	_RandomAccessIterator1 __last_;	259	_RandomAccessIterator1 __last_;
...	@@ -270,7 +270,7 @@ public: // TODO private:	...	@@ -270,7 +270,7 @@ public: // TODO private:
270	const _RandomAccessIterator2 __last = __l - __pattern_length_;	270	const _RandomAccessIterator2 __last = __l - __pattern_length_;
271	const skip_table_type & __skip = *__skip_.get();	271	const skip_table_type & __skip = *__skip_.get();
272	const vector<difference_type> & __suffix = *__suffix_.get();	272	const vector<difference_type> & __suffix = *__suffix_.get();
273		273
274	while (__cur <= __last)	274	while (__cur <= __last)
275	{	275	{
276		276
...	@@ -282,7 +282,7 @@ public: // TODO private:	...	@@ -282,7 +282,7 @@ public: // TODO private:
282	if ( __j == 0 )	282	if ( __j == 0 )
283	return make_pair(__cur, __cur + __pattern_length_);	283	return make_pair(__cur, __cur + __pattern_length_);
284	}	284	}
285		285
286	// Since we didn't match, figure out how far to skip forward	286	// Since we didn't match, figure out how far to skip forward
287	difference_type __k = __skip[__cur [ __j - 1 ]];	287	difference_type __k = __skip[__cur [ __j - 1 ]];
288	difference_type __m = __j - __k - 1;	288	difference_type __m = __j - __k - 1;
...	@@ -291,7 +291,7 @@ public: // TODO private:	...	@@ -291,7 +291,7 @@ public: // TODO private:
291	else	291	else
292	__cur += __suffix[ __j ];	292	__cur += __suffix[ __j ];
293	}	293	}
294		294
295	return make_pair(__l, __l); // We didn't find anything	295	return make_pair(__l, __l); // We didn't find anything
296	}	296	}
297		297
...	@@ -300,21 +300,21 @@ public: // TODO private:	...	@@ -300,21 +300,21 @@ public: // TODO private:
300	void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix )	300	void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix )
301	{	301	{
302	const std::size_t __count = _VSTD::distance(__f, __l);	302	const std::size_t __count = _VSTD::distance(__f, __l);
303		303
304	__prefix[0] = 0;	304	__prefix[0] = 0;
305	std::size_t __k = 0;	305	std::size_t __k = 0;
306	for ( std::size_t __i = 1; __i < __count; ++__i )	306	for ( std::size_t __i = 1; __i < __count; ++__i )
307	{	307	{
308	while ( __k > 0 && !__pred ( __f[__k], __f[__i] ))	308	while ( __k > 0 && !__pred ( __f[__k], __f[__i] ))
309	__k = __prefix [ __k - 1 ];	309	__k = __prefix [ __k - 1 ];
310		310
311	if ( __pred ( __f[__k], __f[__i] ))	311	if ( __pred ( __f[__k], __f[__i] ))
312	__k++;	312	__k++;
313	__prefix [ __i ] = __k;	313	__prefix [ __i ] = __k;
314	}	314	}
315	}	315	}
316		316
317	void __build_suffix_table(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,	317	void __build_suffix_table(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,
318	_BinaryPredicate __pred)	318	_BinaryPredicate __pred)
319	{	319	{
320	const std::size_t __count = _VSTD::distance(__f, __l);	320	const std::size_t __count = _VSTD::distance(__f, __l);
...	@@ -322,19 +322,19 @@ public: // TODO private:	...	@@ -322,19 +322,19 @@ public: // TODO private:
322	if (__count > 0)	322	if (__count > 0)
323	{	323	{
324	_VSTD::vector<value_type> __scratch(__count);	324	_VSTD::vector<value_type> __scratch(__count);
325		325
326	__compute_bm_prefix(__f, __l, __pred, __scratch);	326	__compute_bm_prefix(__f, __l, __pred, __scratch);
327	for ( std::size_t __i = 0; __i <= __count; __i++ )	327	for ( std::size_t __i = 0; __i <= __count; __i++ )
328	__suffix[__i] = __count - __scratch[__count-1];	328	__suffix[__i] = __count - __scratch[__count-1];
329		329
330	typedef _VSTD::reverse_iterator<_RandomAccessIterator1> _RevIter;	330	typedef _VSTD::reverse_iterator<_RandomAccessIterator1> _RevIter;
331	__compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch);	331	__compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch);
332		332
333	for ( std::size_t __i = 0; __i < __count; __i++ )	333	for ( std::size_t __i = 0; __i < __count; __i++ )
334	{	334	{
335	const std::size_t __j = __count - __scratch[__i];	335	const std::size_t __j = __count - __scratch[__i];
336	const difference_type __k = __i - __scratch[__i] + 1;	336	const difference_type __k = __i - __scratch[__i] + 1;
337		337
338	if (__suffix[__j] > __k)	338	if (__suffix[__j] > __k)
339	__suffix[__j] = __k;	339	__suffix[__j] = __k;
340	}	340	}
...	@@ -343,20 +343,20 @@ public: // TODO private:	...	@@ -343,20 +343,20 @@ public: // TODO private:
343		343
344	};	344	};
345		345
346	template<class _RandomAccessIterator,	346	template<class _RandomAccessIterator,
347	class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>,	347	class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>,
348	class _BinaryPredicate = equal_to<>>	348	class _BinaryPredicate = equal_to<>>
349	_LIBCPP_INLINE_VISIBILITY	349	_LIBCPP_INLINE_VISIBILITY
350	boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>	350	boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>
351	make_boyer_moore_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l,	351	make_boyer_moore_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l,
352	_Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())	352	_Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())
353	{	353	{
354	return boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);	354	return boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);
355	}	355	}
356		356
357	// boyer-moore-horspool	357	// boyer-moore-horspool
358	template <class _RandomAccessIterator1,	358	template <class _RandomAccessIterator1,
359	class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,	359	class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
360	class _BinaryPredicate = equal_to<>>	360	class _BinaryPredicate = equal_to<>>
361	class _LIBCPP_TYPE_VIS boyer_moore_horspool_searcher {	361	class _LIBCPP_TYPE_VIS boyer_moore_horspool_searcher {
362	private:	362	private:
...	@@ -370,7 +370,7 @@ private:	...	@@ -370,7 +370,7 @@ private:
370	> skip_table_type;	370	> skip_table_type;
371		371
372	public:	372	public:
373	boyer_moore_horspool_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,	373	boyer_moore_horspool_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,
374	_Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())	374	_Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())
375	: __first_(__f), __last_(__l), __pred_(__pred),	375	: __first_(__f), __last_(__l), __pred_(__pred),
376	__pattern_length_(_VSTD::distance(__first_, __last_)),	376	__pattern_length_(_VSTD::distance(__first_, __last_)),
...	@@ -384,13 +384,13 @@ public:	...	@@ -384,13 +384,13 @@ public:
384	__skip_->insert(*__f, __pattern_length_ - 1 - __i);	384	__skip_->insert(*__f, __pattern_length_ - 1 - __i);
385	}	385	}
386	}	386	}
387		387
388	template <typename _RandomAccessIterator2>	388	template <typename _RandomAccessIterator2>
389	pair<_RandomAccessIterator2, _RandomAccessIterator2>	389	pair<_RandomAccessIterator2, _RandomAccessIterator2>
390	operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const	390	operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
391	{	391	{
392	static_assert ( std::is_same<	392	static_assert ( std::is_same<
393	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,	393	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,
394	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type	394	typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type
395	>::value,	395	>::value,
396	"Corpus and Pattern iterators must point to the same type" );	396	"Corpus and Pattern iterators must point to the same type" );
...	@@ -399,13 +399,13 @@ public:	...	@@ -399,13 +399,13 @@ public:
399	if (__first_ == __last_) return make_pair(__f, __f); // empty pattern	399	if (__first_ == __last_) return make_pair(__f, __f); // empty pattern
400		400
401	// If the pattern is larger than the corpus, we can't find it!	401	// If the pattern is larger than the corpus, we can't find it!
402	if ( __pattern_length_ > _VSTD::distance (__f, __l))	402	if ( __pattern_length_ > _VSTD::distance (__f, __l))
403	return make_pair(__l, __l);	403	return make_pair(__l, __l);
404		404
405	// Do the search	405	// Do the search
406	return this->__search(__f, __l);	406	return this->__search(__f, __l);
407	}	407	}
408		408
409	private:	409	private:
410	_RandomAccessIterator1 __first_;	410	_RandomAccessIterator1 __first_;
411	_RandomAccessIterator1 __last_;	411	_RandomAccessIterator1 __last_;
...	@@ -433,17 +433,17 @@ private:	...	@@ -433,17 +433,17 @@ private:
433	}	433	}
434	__cur += __skip[__cur[__pattern_length_-1]];	434	__cur += __skip[__cur[__pattern_length_-1]];
435	}	435	}
436		436
437	return make_pair(__l, __l);	437	return make_pair(__l, __l);
438	}	438	}
439	};	439	};
440		440
441	template<class _RandomAccessIterator,	441	template<class _RandomAccessIterator,
442	class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>,	442	class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>,
443	class _BinaryPredicate = equal_to<>>	443	class _BinaryPredicate = equal_to<>>
444	_LIBCPP_INLINE_VISIBILITY	444	_LIBCPP_INLINE_VISIBILITY
445	boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>	445	boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>
446	make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l,	446	make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l,
447	_Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())	447	_Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())
448	{	448	{
449	return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);	449	return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);

...	@@ -26,19 +26,19 @@ namespace std {	...	@@ -26,19 +26,19 @@ namespace std {
26	typedef void difference_type;	26	typedef void difference_type;
27	typedef void pointer;	27	typedef void pointer;
28	typedef void reference;	28	typedef void reference;
29		29
30	ostream_joiner(ostream_type& s, const DelimT& delimiter);	30	ostream_joiner(ostream_type& s, const DelimT& delimiter);
31	ostream_joiner(ostream_type& s, DelimT&& delimiter);	31	ostream_joiner(ostream_type& s, DelimT&& delimiter);
32		32
33	template<typename T>	33	template<typename T>
34	ostream_joiner& operator=(const T& value);	34	ostream_joiner& operator=(const T& value);
35		35
36	ostream_joiner& operator*() noexcept;	36	ostream_joiner& operator*() noexcept;
37	ostream_joiner& operator++() noexcept;	37	ostream_joiner& operator++() noexcept;
38	ostream_joiner& operator++(int) noexcept;	38	ostream_joiner& operator++(int) noexcept;
39	private:	39	private:
40	ostream_type* out_stream; // exposition only	40	ostream_type* out_stream; // exposition only
41	DelimT delim; // exposition only	41	DelimT delim; // exposition only
42	bool first_element; // exposition only	42	bool first_element; // exposition only
43	};	43	};
44		44
...	@@ -75,10 +75,10 @@ public:	...	@@ -75,10 +75,10 @@ public:
75		75
76	ostream_joiner(ostream_type& __os, _Delim&& __d)	76	ostream_joiner(ostream_type& __os, _Delim&& __d)
77	: __output_iter(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {}	77	: __output_iter(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {}
78		78
79	ostream_joiner(ostream_type& __os, const _Delim& __d)	79	ostream_joiner(ostream_type& __os, const _Delim& __d)
80	: __output_iter(_VSTD::addressof(__os)), __delim(__d), __first(true) {}	80	: __output_iter(_VSTD::addressof(__os)), __delim(__d), __first(true) {}
81		81
82		82
83	template<typename _Tp>	83	template<typename _Tp>
84	ostream_joiner& operator=(const _Tp& __v)	84	ostream_joiner& operator=(const _Tp& __v)

...	@@ -60,7 +60,7 @@ inline namespace fundamentals_v1 {	...	@@ -60,7 +60,7 @@ inline namespace fundamentals_v1 {
60	using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;	60	using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
61	template <class To, template<class...> class Op, class... Args>	61	template <class To, template<class...> class Op, class... Args>
62	constexpr bool is_detected_convertible_v	62	constexpr bool is_detected_convertible_v
63	= is_detected_convertible<To, Op, Args...>::value;	63	= is_detected_convertible<To, Op, Args...>::value;
64		64
65	} // namespace fundamentals_v1	65	} // namespace fundamentals_v1
66	} // namespace experimental	66	} // namespace experimental
...	@@ -122,7 +122,7 @@ struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> {	...	@@ -122,7 +122,7 @@ struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> {
122	using value_t = true_type;	122	using value_t = true_type;
123	using type = _Op<_Args...>;	123	using type = _Op<_Args...>;
124	};	124	};
125		125
126		126
127	template <template<class...> class _Op, class... _Args>	127	template <template<class...> class _Op, class... _Args>
128	using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;	128	using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;
...	@@ -144,7 +144,7 @@ template <class Expected, template<class...> class _Op, class... _Args>	...	@@ -144,7 +144,7 @@ template <class Expected, template<class...> class _Op, class... _Args>
144	template <class To, template<class...> class _Op, class... _Args>	144	template <class To, template<class...> class _Op, class... _Args>
145	using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>;	145	using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>;
146	template <class To, template<class...> class _Op, class... _Args>	146	template <class To, template<class...> class _Op, class... _Args>
147	_LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value;	147	_LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value;
148		148
149		149
150	_LIBCPP_END_NAMESPACE_LFTS	150	_LIBCPP_END_NAMESPACE_LFTS

...	@@ -1474,26 +1474,26 @@ private:	...	@@ -1474,26 +1474,26 @@ private:
1474	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES	1474	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1475	template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,	1475	template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,
1476	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,	1476	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
1477	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	1477	class = _EnableIf<!__is_allocator<_Compare>::value, void>,
1478	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1478	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
1479	map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())	1479	map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
1480	-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;	1480	-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
1481		1481
1482	template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,	1482	template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
1483	class _Allocator = allocator<pair<const _Key, _Tp>>,	1483	class _Allocator = allocator<pair<const _Key, _Tp>>,
1484	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	1484	class = _EnableIf<!__is_allocator<_Compare>::value, void>,
1485	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1485	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
1486	map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())	1486	map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
1487	-> map<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;	1487	-> map<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
1488		1488
1489	template<class _InputIterator, class _Allocator,	1489	template<class _InputIterator, class _Allocator,
1490	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1490	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
1491	map(_InputIterator, _InputIterator, _Allocator)	1491	map(_InputIterator, _InputIterator, _Allocator)
1492	-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,	1492	-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
1493	less<__iter_key_type<_InputIterator>>, _Allocator>;	1493	less<__iter_key_type<_InputIterator>>, _Allocator>;
1494		1494
1495	template<class _Key, class _Tp, class _Allocator,	1495	template<class _Key, class _Tp, class _Allocator,
1496	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1496	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
1497	map(initializer_list<pair<_Key, _Tp>>, _Allocator)	1497	map(initializer_list<pair<_Key, _Tp>>, _Allocator)
1498	-> map<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;	1498	-> map<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
1499	#endif	1499	#endif
...	@@ -2131,26 +2131,26 @@ private:	...	@@ -2131,26 +2131,26 @@ private:
2131	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES	2131	#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
2132	template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,	2132	template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,
2133	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,	2133	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
2134	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	2134	class = _EnableIf<!__is_allocator<_Compare>::value, void>,
2135	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2135	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
2136	multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())	2136	multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
2137	-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;	2137	-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
2138		2138
2139	template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,	2139	template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
2140	class _Allocator = allocator<pair<const _Key, _Tp>>,	2140	class _Allocator = allocator<pair<const _Key, _Tp>>,
2141	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	2141	class = _EnableIf<!__is_allocator<_Compare>::value, void>,
2142	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2142	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
2143	multimap(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())	2143	multimap(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
2144	-> multimap<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;	2144	-> multimap<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
2145		2145
2146	template<class _InputIterator, class _Allocator,	2146	template<class _InputIterator, class _Allocator,
2147	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2147	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
2148	multimap(_InputIterator, _InputIterator, _Allocator)	2148	multimap(_InputIterator, _InputIterator, _Allocator)
2149	-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,	2149	-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
2150	less<__iter_key_type<_InputIterator>>, _Allocator>;	2150	less<__iter_key_type<_InputIterator>>, _Allocator>;
2151		2151
2152	template<class _Key, class _Tp, class _Allocator,	2152	template<class _Key, class _Tp, class _Allocator,
2153	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2153	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
2154	multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)	2154	multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
2155	-> multimap<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;	2155	-> multimap<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
2156	#endif	2156	#endif

...	@@ -852,26 +852,26 @@ public:	...	@@ -852,26 +852,26 @@ public:
852	template<class _InputIterator,	852	template<class _InputIterator,
853	class _Compare = less<typename iterator_traits<_InputIterator>::value_type>,	853	class _Compare = less<typename iterator_traits<_InputIterator>::value_type>,
854	class _Allocator = allocator<typename iterator_traits<_InputIterator>::value_type>,	854	class _Allocator = allocator<typename iterator_traits<_InputIterator>::value_type>,
855	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type,	855	class = _EnableIf<__is_allocator<_Allocator>::value, void>,
856	class = typename enable_if<!__is_allocator<_Compare>::value, void>::type>	856	class = _EnableIf<!__is_allocator<_Compare>::value, void>>
857	set(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())	857	set(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
858	-> set<typename iterator_traits<_InputIterator>::value_type, _Compare, _Allocator>;	858	-> set<typename iterator_traits<_InputIterator>::value_type, _Compare, _Allocator>;
859		859
860	template<class _Key, class _Compare = less<_Key>,	860	template<class _Key, class _Compare = less<_Key>,
861	class _Allocator = allocator<_Key>,	861	class _Allocator = allocator<_Key>,
862	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type,	862	class = _EnableIf<__is_allocator<_Allocator>::value, void>,
863	class = typename enable_if<!__is_allocator<_Compare>::value, void>::type>	863	class = _EnableIf<!__is_allocator<_Compare>::value, void>>
864	set(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator())	864	set(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator())
865	-> set<_Key, _Compare, _Allocator>;	865	-> set<_Key, _Compare, _Allocator>;
866		866
867	template<class _InputIterator, class _Allocator,	867	template<class _InputIterator, class _Allocator,
868	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>	868	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
869	set(_InputIterator, _InputIterator, _Allocator)	869	set(_InputIterator, _InputIterator, _Allocator)
870	-> set<typename iterator_traits<_InputIterator>::value_type,	870	-> set<typename iterator_traits<_InputIterator>::value_type,
871	less<typename iterator_traits<_InputIterator>::value_type>, _Allocator>;	871	less<typename iterator_traits<_InputIterator>::value_type>, _Allocator>;
872		872
873	template<class _Key, class _Allocator,	873	template<class _Key, class _Allocator,
874	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>	874	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
875	set(initializer_list<_Key>, _Allocator)	875	set(initializer_list<_Key>, _Allocator)
876	-> set<_Key, less<_Key>, _Allocator>;	876	-> set<_Key, less<_Key>, _Allocator>;
877	#endif	877	#endif
...	@@ -1377,26 +1377,26 @@ public:	...	@@ -1377,26 +1377,26 @@ public:
1377	template<class _InputIterator,	1377	template<class _InputIterator,
1378	class _Compare = less<typename iterator_traits<_InputIterator>::value_type>,	1378	class _Compare = less<typename iterator_traits<_InputIterator>::value_type>,
1379	class _Allocator = allocator<typename iterator_traits<_InputIterator>::value_type>,	1379	class _Allocator = allocator<typename iterator_traits<_InputIterator>::value_type>,
1380	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type,	1380	class = _EnableIf<__is_allocator<_Allocator>::value, void>,
1381	class = typename enable_if<!__is_allocator<_Compare>::value, void>::type>	1381	class = _EnableIf<!__is_allocator<_Compare>::value, void>>
1382	multiset(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())	1382	multiset(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
1383	-> multiset<typename iterator_traits<_InputIterator>::value_type, _Compare, _Allocator>;	1383	-> multiset<typename iterator_traits<_InputIterator>::value_type, _Compare, _Allocator>;
1384		1384
1385	template<class _Key, class _Compare = less<_Key>,	1385	template<class _Key, class _Compare = less<_Key>,
1386	class _Allocator = allocator<_Key>,	1386	class _Allocator = allocator<_Key>,
1387	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type,	1387	class = _EnableIf<__is_allocator<_Allocator>::value, void>,
1388	class = typename enable_if<!__is_allocator<_Compare>::value, void>::type>	1388	class = _EnableIf<!__is_allocator<_Compare>::value, void>>
1389	multiset(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator())	1389	multiset(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator())
1390	-> multiset<_Key, _Compare, _Allocator>;	1390	-> multiset<_Key, _Compare, _Allocator>;
1391		1391
1392	template<class _InputIterator, class _Allocator,	1392	template<class _InputIterator, class _Allocator,
1393	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>	1393	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
1394	multiset(_InputIterator, _InputIterator, _Allocator)	1394	multiset(_InputIterator, _InputIterator, _Allocator)
1395	-> multiset<typename iterator_traits<_InputIterator>::value_type,	1395	-> multiset<typename iterator_traits<_InputIterator>::value_type,
1396	less<typename iterator_traits<_InputIterator>::value_type>, _Allocator>;	1396	less<typename iterator_traits<_InputIterator>::value_type>, _Allocator>;
1397		1397
1398	template<class _Key, class _Allocator,	1398	template<class _Key, class _Allocator,
1399	class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>	1399	class = _EnableIf<__is_allocator<_Allocator>::value, void>>
1400	multiset(initializer_list<_Key>, _Allocator)	1400	multiset(initializer_list<_Key>, _Allocator)
1401	-> multiset<_Key, less<_Key>, _Allocator>;	1401	-> multiset<_Key, less<_Key>, _Allocator>;
1402	#endif	1402	#endif

...	@@ -43,6 +43,7 @@ __cpp_lib_constexpr_misc 201811L <array> <functio	...	@@ -43,6 +43,7 @@ __cpp_lib_constexpr_misc 201811L <array> <functio
43	__cpp_lib_constexpr_swap_algorithms 201806L <algorithm>	43	__cpp_lib_constexpr_swap_algorithms 201806L <algorithm>
44	__cpp_lib_destroying_delete 201806L <new>	44	__cpp_lib_destroying_delete 201806L <new>
45	__cpp_lib_enable_shared_from_this 201603L <memory>	45	__cpp_lib_enable_shared_from_this 201603L <memory>
		46	__cpp_lib_endian 201907L <bit>
46	__cpp_lib_erase_if 201811L <string> <deque> <forward_list>	47	__cpp_lib_erase_if 201811L <string> <deque> <forward_list>
47	<list> <vector> <map>	48	<list> <vector> <map>
48	<set> <unordered_map> <unordered_set>	49	<set> <unordered_map> <unordered_set>
...	@@ -223,6 +224,7 @@ __cpp_lib_void_t 201411L <type_traits>	...	@@ -223,6 +224,7 @@ __cpp_lib_void_t 201411L <type_traits>
223	# if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L	224	# if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
224	# define __cpp_lib_destroying_delete 201806L	225	# define __cpp_lib_destroying_delete 201806L
225	# endif	226	# endif
		227	# define __cpp_lib_endian 201907L
226	# define __cpp_lib_erase_if 201811L	228	# define __cpp_lib_erase_if 201811L
227	// # define __cpp_lib_generic_unordered_lookup 201811L	229	// # define __cpp_lib_generic_unordered_lookup 201811L
228	# define __cpp_lib_interpolate 201902L	230	# define __cpp_lib_interpolate 201902L

update libcxx to llvm10.0.0rc2