diff --git a/stl/inc/__msvc_string_view.hpp b/stl/inc/__msvc_string_view.hpp index cc82be25c53..bd8105e0815 100644 --- a/stl/inc/__msvc_string_view.hpp +++ b/stl/inc/__msvc_string_view.hpp @@ -19,7 +19,6 @@ _STL_DISABLE_CLANG_WARNINGS #pragma push_macro("new") #undef new -#if _USE_STD_VECTOR_ALGORITHMS extern "C" { // The "noalias" attribute tells the compiler optimizer that pointers going into these hand-vectorized algorithms // won't be stored beyond the lifetime of the function, and that the function will only reference arrays denoted by @@ -29,6 +28,7 @@ extern "C" { // compiler has to assume that the denoted arrays are "globally address taken", and that any later calls to // unanalyzable routines may modify those arrays. +#if _VECTORIZED_FIND_FIRST_OF __declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_1( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; __declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_2( @@ -37,17 +37,23 @@ __declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_4( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; __declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_8( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ +#if _VECTORIZED_FIND_LAST_OF __declspec(noalias) size_t __stdcall __std_find_last_of_trivial_pos_1( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; __declspec(noalias) size_t __stdcall __std_find_last_of_trivial_pos_2( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; +#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^ +#if _VECTORIZED_FIND const void* __stdcall __std_find_not_ch_1(const void* _First, const void* _Last, uint8_t _Val) noexcept; const void* __stdcall __std_find_not_ch_2(const void* _First, const void* _Last, uint16_t _Val) noexcept; const void* __stdcall __std_find_not_ch_4(const void* _First, const void* _Last, uint32_t _Val) noexcept; const void* __stdcall __std_find_not_ch_8(const void* _First, const void* _Last, uint64_t _Val) noexcept; +#endif // ^^^ _VECTORIZED_FIND ^^^ +#if _VECTORIZED_FIND_LAST __declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_1( const void* _First, const void* _Last, uint8_t _Val) noexcept; __declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_2( @@ -56,21 +62,27 @@ __declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_4( const void* _First, const void* _Last, uint32_t _Val) noexcept; __declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_8( const void* _First, const void* _Last, uint64_t _Val) noexcept; +#endif // ^^^ _VECTORIZED_FIND_LAST ^^^ +#if _VECTORIZED_FIND_FIRST_OF __declspec(noalias) size_t __stdcall __std_find_first_not_of_trivial_pos_1( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; __declspec(noalias) size_t __stdcall __std_find_first_not_of_trivial_pos_2( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ +#if _VECTORIZED_FIND_LAST_OF __declspec(noalias) size_t __stdcall __std_find_last_not_of_trivial_pos_1( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; __declspec(noalias) size_t __stdcall __std_find_last_not_of_trivial_pos_2( const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept; +#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^ } // extern "C" _STD_BEGIN +#if _VECTORIZED_FIND_FIRST_OF template size_t _Find_first_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length, const _Ty2* const _Needle, const size_t _Needle_length) noexcept { @@ -87,7 +99,9 @@ size_t _Find_first_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _ _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ +#if _VECTORIZED_FIND_LAST_OF template size_t _Find_last_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length, const _Ty2* const _Needle, const size_t _Needle_length) noexcept { @@ -100,7 +114,9 @@ size_t _Find_last_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _H _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^ +#if _VECTORIZED_FIND template const _Ty* _Find_not_ch_vectorized(const _Ty* const _First, const _Ty* const _Last, const _Ty _Ch) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -115,7 +131,9 @@ const _Ty* _Find_not_ch_vectorized(const _Ty* const _First, const _Ty* const _La _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND ^^^ +#if _VECTORIZED_FIND_LAST template size_t _Find_last_not_ch_pos_vectorized(const _Ty* const _First, const _Ty* const _Last, const _Ty _Ch) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -130,6 +148,9 @@ size_t _Find_last_not_ch_pos_vectorized(const _Ty* const _First, const _Ty* cons _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_LAST ^^^ + +#if _VECTORIZED_FIND_FIRST_OF template size_t _Find_first_not_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length, const _Ty2* const _Needle, const size_t _Needle_length) noexcept { @@ -142,7 +163,9 @@ size_t _Find_first_not_of_pos_vectorized(const _Ty1* const _Haystack, const size _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ +#if _VECTORIZED_FIND_LAST_OF template size_t _Find_last_not_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length, const _Ty2* const _Needle, const size_t _Needle_length) noexcept { @@ -155,12 +178,8 @@ size_t _Find_last_not_of_pos_vectorized(const _Ty1* const _Haystack, const size_ _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^ -_STD_END - -#endif // _USE_STD_VECTOR_ALGORITHMS - -_STD_BEGIN #ifdef __clang__ #define _HAS_MEMCPY_MEMMOVE_INTRINSICS 1 #else // ^^^ use __builtin_memcpy and __builtin_memmove / use workaround vvv @@ -360,7 +379,7 @@ struct _WChar_traits : private _Char_traits<_Elem, unsigned short> { _NODISCARD static _CONSTEXPR17 int compare(_In_reads_(_Count) const _Elem* const _First1, _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ { // compare [_First1, _First1 + _Count) with [_First2, ...) -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH if (!_STD _Is_constant_evaluated()) { // TRANSITION, GH-2289: Use vectorized algorithms for better performance than __builtin_wmemcmp. const size_t _Pos = _Mismatch_vectorized(_First1, _First2, _Count); @@ -370,7 +389,7 @@ struct _WChar_traits : private _Char_traits<_Elem, unsigned short> { return _First1[_Pos] < _First2[_Pos] ? -1 : +1; } } -#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ _VECTORIZED_MISMATCH ^^^ if constexpr (is_same_v<_Elem, wchar_t>) { return __builtin_wmemcmp(_First1, _First2, _Count); @@ -728,7 +747,7 @@ constexpr size_t _Traits_find(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> return _Start_at; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH if constexpr (_Is_implementation_handled_char_traits<_Traits>) { if (!_STD _Is_constant_evaluated()) { const auto _End = _Haystack + _Hay_size; @@ -741,7 +760,7 @@ constexpr size_t _Traits_find(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SEARCH ^^^ const auto _Possible_matches_end = _Haystack + (_Hay_size - _Needle_size) + 1; for (auto _Match_try = _Haystack + _Start_at;; ++_Match_try) { @@ -764,7 +783,7 @@ constexpr size_t _Traits_find_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Trai return static_cast(-1); // (npos) no room for match } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND if constexpr (_Is_implementation_handled_char_traits<_Traits>) { if (!_STD _Is_constant_evaluated()) { const auto _End = _Haystack + _Hay_size; @@ -777,7 +796,7 @@ constexpr size_t _Traits_find_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Trai } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND ^^^ const auto _Found_at = _Traits::find(_Haystack + _Start_at, _Hay_size - _Start_at, _Ch); if (_Found_at) { @@ -802,7 +821,7 @@ constexpr size_t _Traits_rfind(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits const size_t _Actual_start_at = (_STD min) (_Start_at, _Hay_size - _Needle_size); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_END if constexpr (_Is_implementation_handled_char_traits<_Traits>) { if (!_STD _Is_constant_evaluated()) { // _Find_end_vectorized takes into account the needle length when locating the search start. @@ -819,7 +838,7 @@ constexpr size_t _Traits_rfind(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_END ^^^ for (auto _Match_try = _Haystack + _Actual_start_at;; --_Match_try) { if (_Traits::eq(*_Match_try, *_Needle) && _Traits::compare(_Match_try, _Needle, _Needle_size) == 0) { @@ -843,7 +862,7 @@ constexpr size_t _Traits_rfind_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Tra const size_t _Actual_start_at = (_STD min) (_Start_at, _Hay_size - 1); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_LAST if constexpr (_Is_implementation_handled_char_traits<_Traits>) { if (!_STD _Is_constant_evaluated()) { const auto _End = _Haystack + _Actual_start_at + 1; @@ -856,7 +875,7 @@ constexpr size_t _Traits_rfind_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Tra } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_LAST ^^^ for (auto _Match_try = _Haystack + _Actual_start_at;; --_Match_try) { if (_Traits::eq(*_Match_try, _Ch)) { @@ -934,7 +953,7 @@ constexpr size_t _Traits_find_first_of(_In_reads_(_Hay_size) const _Traits_ptr_t const auto _Hay_end = _Haystack + _Hay_size; if constexpr (_Is_implementation_handled_char_traits<_Traits>) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_FIRST_OF if (!_STD _Is_constant_evaluated()) { const size_t _Remaining_size = _Hay_size - _Start_at; if (_Remaining_size + _Needle_size >= _Threshold_find_first_of) { @@ -945,7 +964,7 @@ constexpr size_t _Traits_find_first_of(_In_reads_(_Hay_size) const _Traits_ptr_t return _Pos; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ _String_bitmap _Matches; @@ -983,7 +1002,7 @@ constexpr size_t _Traits_find_last_of(_In_reads_(_Hay_size) const _Traits_ptr_t< if constexpr (_Is_implementation_handled_char_traits<_Traits>) { using _Elem = typename _Traits::char_type; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_LAST_OF if constexpr (sizeof(_Elem) <= 2) { if (!_STD _Is_constant_evaluated()) { const size_t _Remaining_size = _Hay_start + 1; @@ -992,7 +1011,7 @@ constexpr size_t _Traits_find_last_of(_In_reads_(_Hay_size) const _Traits_ptr_t< } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^ _String_bitmap<_Elem> _Matches; if (_Matches._Mark(_Needle, _Needle + _Needle_size)) { @@ -1035,7 +1054,7 @@ constexpr size_t _Traits_find_first_not_of(_In_reads_(_Hay_size) const _Traits_p if constexpr (_Is_implementation_handled_char_traits<_Traits>) { using _Elem = typename _Traits::char_type; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_FIRST_OF if constexpr (sizeof(_Elem) <= 2) { if (!_STD _Is_constant_evaluated()) { const size_t _Remaining_size = _Hay_size - _Start_at; @@ -1048,7 +1067,7 @@ constexpr size_t _Traits_find_first_not_of(_In_reads_(_Hay_size) const _Traits_p } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ _String_bitmap<_Elem> _Matches; if (_Matches._Mark(_Needle, _Needle + _Needle_size)) { @@ -1082,7 +1101,7 @@ constexpr size_t _Traits_find_not_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_ const auto _End = _Haystack + _Hay_size; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND if constexpr (_Is_implementation_handled_char_traits<_Traits>) { if (!_STD _Is_constant_evaluated()) { const auto _Result = _STD _Find_not_ch_vectorized(_Haystack + _Start_at, _End, _Ch); @@ -1093,7 +1112,7 @@ constexpr size_t _Traits_find_not_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_ } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND ^^^ for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try) { if (!_Traits::eq(*_Match_try, _Ch)) { @@ -1117,7 +1136,7 @@ constexpr size_t _Traits_find_last_not_of(_In_reads_(_Hay_size) const _Traits_pt if constexpr (_Is_implementation_handled_char_traits<_Traits>) { using _Elem = typename _Traits::char_type; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_LAST_OF if constexpr (sizeof(_Elem) <= 2) { if (!_STD _Is_constant_evaluated()) { const size_t _Remaining_size = _Hay_start + 1; @@ -1126,7 +1145,7 @@ constexpr size_t _Traits_find_last_not_of(_In_reads_(_Hay_size) const _Traits_pt } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^ _String_bitmap<_Elem> _Matches; if (_Matches._Mark(_Needle, _Needle + _Needle_size)) { @@ -1165,13 +1184,13 @@ constexpr size_t _Traits_rfind_not_ch(_In_reads_(_Hay_size) const _Traits_ptr_t< const size_t _Actual_start_at = (_STD min) (_Start_at, _Hay_size - 1); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_LAST if constexpr (_Is_implementation_handled_char_traits<_Traits>) { if (!_STD _Is_constant_evaluated()) { return _STD _Find_last_not_ch_pos_vectorized(_Haystack, _Haystack + _Actual_start_at + 1, _Ch); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_LAST ^^^ for (auto _Match_try = _Haystack + _Actual_start_at;; --_Match_try) { if (!_Traits::eq(*_Match_try, _Ch)) { diff --git a/stl/inc/algorithm b/stl/inc/algorithm index cb5511d5742..e1af3d2818a 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -29,8 +29,6 @@ _STL_DISABLE_CLANG_WARNINGS #undef msvc #undef lifetimebound -#if _USE_STD_VECTOR_ALGORITHMS - extern "C" { // The "noalias" attribute tells the compiler optimizer that pointers going into these hand-vectorized algorithms // won't be stored beyond the lifetime of the function, and that the function will only reference arrays denoted by @@ -39,6 +37,8 @@ extern "C" { // functions are in native code objects that the compiler cannot analyze. In the absence of the noalias attribute, the // compiler has to assume that the denoted arrays are "globally address taken", and that any later calls to // unanalyzable routines may modify those arrays. + +#if _VECTORIZED_FIND_FIRST_OF const void* __stdcall __std_find_first_of_trivial_1( const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept; const void* __stdcall __std_find_first_of_trivial_2( @@ -47,7 +47,9 @@ const void* __stdcall __std_find_first_of_trivial_4( const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept; const void* __stdcall __std_find_first_of_trivial_8( const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept; +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ +#if _VECTORIZED_REVERSE_COPY __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_1( const void* _First, const void* _Last, void* _Dest) noexcept; __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_2( @@ -56,14 +58,18 @@ __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_4( const void* _First, const void* _Last, void* _Dest) noexcept; __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_8( const void* _First, const void* _Last, void* _Dest) noexcept; +#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^ +#if _VECTORIZED_MINMAX_ELEMENT _Min_max_element_t __stdcall __std_minmax_element_1(const void* _First, const void* _Last, bool _Signed) noexcept; _Min_max_element_t __stdcall __std_minmax_element_2(const void* _First, const void* _Last, bool _Signed) noexcept; _Min_max_element_t __stdcall __std_minmax_element_4(const void* _First, const void* _Last, bool _Signed) noexcept; _Min_max_element_t __stdcall __std_minmax_element_8(const void* _First, const void* _Last, bool _Signed) noexcept; _Min_max_element_t __stdcall __std_minmax_element_f(const void* _First, const void* _Last, bool _Unused) noexcept; _Min_max_element_t __stdcall __std_minmax_element_d(const void* _First, const void* _Last, bool _Unused) noexcept; +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ +#if _VECTORIZED_MINMAX __declspec(noalias) _Min_max_1i __stdcall __std_minmax_1i(const void* _First, const void* _Last) noexcept; __declspec(noalias) _Min_max_1u __stdcall __std_minmax_1u(const void* _First, const void* _Last) noexcept; __declspec(noalias) _Min_max_2i __stdcall __std_minmax_2i(const void* _First, const void* _Last) noexcept; @@ -74,7 +80,9 @@ __declspec(noalias) _Min_max_8i __stdcall __std_minmax_8i(const void* _First, co __declspec(noalias) _Min_max_8u __stdcall __std_minmax_8u(const void* _First, const void* _Last) noexcept; __declspec(noalias) _Min_max_f __stdcall __std_minmax_f(const void* _First, const void* _Last) noexcept; __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, const void* _Last) noexcept; +#endif // ^^^ _VECTORIZED_MINMAX ^^^ +#if _VECTORIZED_IS_SORTED_UNTIL const void* __stdcall __std_is_sorted_until_1i(const void* _First, const void* _Last, bool _Greater) noexcept; const void* __stdcall __std_is_sorted_until_1u(const void* _First, const void* _Last, bool _Greater) noexcept; const void* __stdcall __std_is_sorted_until_2i(const void* _First, const void* _Last, bool _Greater) noexcept; @@ -85,7 +93,9 @@ const void* __stdcall __std_is_sorted_until_8i(const void* _First, const void* _ const void* __stdcall __std_is_sorted_until_8u(const void* _First, const void* _Last, bool _Greater) noexcept; const void* __stdcall __std_is_sorted_until_f(const void* _First, const void* _Last, bool _Greater) noexcept; const void* __stdcall __std_is_sorted_until_d(const void* _First, const void* _Last, bool _Greater) noexcept; +#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^ +#if _VECTORIZED_INCLUDES __declspec(noalias) bool __stdcall __std_includes_less_1i( const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept; __declspec(noalias) bool __stdcall __std_includes_less_1u( @@ -102,35 +112,49 @@ __declspec(noalias) bool __stdcall __std_includes_less_8i( const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept; __declspec(noalias) bool __stdcall __std_includes_less_8u( const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept; +#endif // ^^^ _VECTORIZED_INCLUDES ^^^ +#if _VECTORIZED_REPLACE // TRANSITION, DevCom-10610477 __declspec(noalias) void __stdcall __std_replace_4( void* _First, void* _Last, uint32_t _Old_val, uint32_t _New_val) noexcept; __declspec(noalias) void __stdcall __std_replace_8( void* _First, void* _Last, uint64_t _Old_val, uint64_t _New_val) noexcept; +#endif // ^^^ _VECTORIZED_REPLACE ^^^ +#if _VECTORIZED_SEARCH_N const void* __stdcall __std_search_n_1(const void* _First, const void* _Last, size_t _Count, uint8_t _Value) noexcept; const void* __stdcall __std_search_n_2(const void* _First, const void* _Last, size_t _Count, uint16_t _Value) noexcept; const void* __stdcall __std_search_n_4(const void* _First, const void* _Last, size_t _Count, uint32_t _Value) noexcept; const void* __stdcall __std_search_n_8(const void* _First, const void* _Last, size_t _Count, uint64_t _Value) noexcept; +#endif // ^^^ _VECTORIZED_SEARCH_N ^^^ +#if _VECTORIZED_REMOVE_COPY void* __stdcall __std_remove_copy_1(const void* _First, const void* _Last, void* _Out, uint8_t _Val) noexcept; void* __stdcall __std_remove_copy_2(const void* _First, const void* _Last, void* _Out, uint16_t _Val) noexcept; void* __stdcall __std_remove_copy_4(const void* _First, const void* _Last, void* _Out, uint32_t _Val) noexcept; void* __stdcall __std_remove_copy_8(const void* _First, const void* _Last, void* _Out, uint64_t _Val) noexcept; +#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^ +#if _VECTORIZED_UNIQUE void* __stdcall __std_unique_1(void* _First, void* _Last) noexcept; void* __stdcall __std_unique_2(void* _First, void* _Last) noexcept; void* __stdcall __std_unique_4(void* _First, void* _Last) noexcept; void* __stdcall __std_unique_8(void* _First, void* _Last) noexcept; +#endif // ^^^ _VECTORIZED_UNIQUE ^^^ +#if _VECTORIZED_UNIQUE_COPY void* __stdcall __std_unique_copy_1(const void* _First, const void* _Last, void* _Dest) noexcept; void* __stdcall __std_unique_copy_2(const void* _First, const void* _Last, void* _Dest) noexcept; void* __stdcall __std_unique_copy_4(const void* _First, const void* _Last, void* _Dest) noexcept; void* __stdcall __std_unique_copy_8(const void* _First, const void* _Last, void* _Dest) noexcept; +#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^ + } // extern "C" _STD_BEGIN + +#if _VECTORIZED_FIND_FIRST_OF template _Ty1* _Find_first_of_vectorized( _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept { @@ -151,7 +175,9 @@ _Ty1* _Find_first_of_vectorized( _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ +#if _VECTORIZED_REVERSE_COPY template __declspec(noalias) void _Reverse_copy_vectorized(const void* _First, const void* _Last, void* _Dest) noexcept { if constexpr (_Nx == 1) { @@ -166,7 +192,9 @@ __declspec(noalias) void _Reverse_copy_vectorized(const void* _First, const void _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^ +#if _VECTORIZED_MINMAX_ELEMENT template pair<_Ty*, _Ty*> _Minmax_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; @@ -191,7 +219,9 @@ pair<_Ty*, _Ty*> _Minmax_element_vectorized(_Ty* const _First, _Ty* const _Last) return {const_cast<_Ty*>(static_cast(_Res._Min)), const_cast<_Ty*>(static_cast(_Res._Max))}; } +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ +#if _VECTORIZED_MINMAX template auto _Minmax_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; @@ -235,7 +265,9 @@ auto _Minmax_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_MINMAX ^^^ +#if _VECTORIZED_IS_SORTED_UNTIL template _Ty* _Is_sorted_until_vectorized(_Ty* const _First, _Ty* const _Last, const bool _Greater) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; @@ -272,7 +304,9 @@ _Ty* _Is_sorted_until_vectorized(_Ty* const _First, _Ty* const _Last, const bool _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^ +#if _VECTORIZED_INCLUDES template bool _Includes_vectorized( const _Ty* const _First1, const _Ty* const _Last1, const _Ty* const _First2, const _Ty* const _Last2) noexcept { @@ -306,7 +340,9 @@ bool _Includes_vectorized( _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_INCLUDES ^^^ +#if _VECTORIZED_REPLACE template __declspec(noalias) void _Replace_vectorized( _Ty* const _First, _Ty* const _Last, const _TVal1 _Old_val, const _TVal2 _New_val) noexcept { @@ -320,7 +356,9 @@ __declspec(noalias) void _Replace_vectorized( _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_REPLACE ^^^ +#if _VECTORIZED_SEARCH_N template _Ty* _Search_n_vectorized(_Ty* const _First, _Ty* const _Last, const size_t _Count, const _TVal _Val) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -339,7 +377,9 @@ _Ty* _Search_n_vectorized(_Ty* const _First, _Ty* const _Last, const size_t _Cou _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_SEARCH_N ^^^ +#if _VECTORIZED_UNIQUE template _Ty* _Unique_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -354,7 +394,9 @@ _Ty* _Unique_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { _STL_INTERNAL_STATIC_ASSERT(false); // Unexpected size } } +#endif // ^^^ _VECTORIZED_UNIQUE ^^^ +#if _VECTORIZED_REMOVE_COPY template _Ty* _Remove_copy_vectorized( const _Ty* const _First, const _Ty* const _Last, _Ty* const _Dest, const _TVal _Val) noexcept { @@ -370,7 +412,9 @@ _Ty* _Remove_copy_vectorized( _STL_INTERNAL_STATIC_ASSERT(false); // Unexpected size } } +#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^ +#if _VECTORIZED_UNIQUE_COPY template _Ty* _Unique_copy_vectorized(const _Ty* const _First, const _Ty* const _Last, _Ty* const _Dest) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -385,6 +429,9 @@ _Ty* _Unique_copy_vectorized(const _Ty* const _First, const _Ty* const _Last, _T _STL_INTERNAL_STATIC_ASSERT(false); // Unexpected size } } +#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^ + +#if _VECTORIZED_REPLACE // Can we activate the vector algorithms for replace? template constexpr bool _Vector_alg_in_replace_is_safe = _Vector_alg_in_find_is_safe<_Iter, _Ty1> // can search for the value @@ -395,7 +442,10 @@ template constexpr bool _Vector_alg_in_ranges_replace_is_safe = _Vector_alg_in_replace_is_safe<_Iter, _Ty1> // can search and replace && _Vector_alg_in_find_is_safe_elem<_Ty2, _Iter_value_t<_Iter>>; // replacement fits +#endif // ^^^ _VECTORIZED_REPLACE ^^^ +#if _VECTORIZED_SEARCH_N +// Can we activate the vector algorithms for search_n? template constexpr bool _Vector_alg_in_search_n_is_safe = _Vector_alg_in_find_is_safe<_Iter, _Ty> && _Is_any_of_v<_Pr, @@ -403,11 +453,16 @@ constexpr bool _Vector_alg_in_search_n_is_safe = _Vector_alg_in_find_is_safe<_It ranges::equal_to, #endif equal_to<>>; -// Can we activate the vector algorithms for unique? +#endif // ^^^ _VECTORIZED_SEARCH_N ^^^ + +#if _VECTORIZED_UNIQUE || _VECTORIZED_UNIQUE_COPY +// Can we activate the vector algorithms for unique and unique_copy? template constexpr bool _Vector_alg_in_unique_is_safe = _Vector_alg_in_search_is_safe<_Iter, _Iter, _Pr>; +#endif // ^^^ _VECTORIZED_UNIQUE || _VECTORIZED_UNIQUE_COPY ^^^ -// Can we use this output iterator for remove_copy or unique_copy? +#if _VECTORIZED_REMOVE_COPY || _VECTORIZED_UNIQUE_COPY +// Can we use this output iterator for remove_copy and unique_copy? template constexpr bool _Output_iterator_for_vector_alg_is_safe() { if constexpr (_Iterator_is_contiguous<_Out>) { @@ -416,7 +471,9 @@ constexpr bool _Output_iterator_for_vector_alg_is_safe() { return false; } } +#endif // ^^^ _VECTORIZED_REMOVE_COPY || _VECTORIZED_UNIQUE_COPY ^^^ +#if _VECTORIZED_INCLUDES // Can we activate the vector algorithms for includes? template > constexpr bool _Vector_alg_includes_iterators_safe = @@ -424,10 +481,8 @@ constexpr bool _Vector_alg_includes_iterators_safe = && !_Iterator_is_volatile<_Iter1> && !_Iterator_is_volatile<_Iter2> // Iterators must not be volatile. && is_same_v<_Elem, _Iter_value_t<_Iter2>> // Iterators have the same value type. && disjunction_v, is_pointer<_Elem>>; // Integral or pointer type. -_STD_END -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_INCLUDES ^^^ -_STD_BEGIN #define _REQUIRE_CPP17_MUTABLE_RANDOM_ACCESS_ITERATOR(_Iter) \ static_assert(_Is_cpp17_random_iter_v<_Iter>, \ "This algorithm requires that mutable iterators be Cpp17RandomAccessIterators or stronger.") @@ -748,7 +803,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last, auto _UFirst = _STD _Get_unwrapped(_First); auto _ULast = _STD _Get_unwrapped(_Last); if (_UFirst != _ULast) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_ADJACENT_FIND if constexpr (_Vector_alg_in_search_is_safe) { if (!_STD _Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_UFirst); @@ -764,7 +819,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last, return _Last; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^ for (auto _UNext = _UFirst; ++_UNext != _ULast; _UFirst = _UNext) { if (_Pred(*_UFirst, *_UNext)) { @@ -822,7 +877,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>); _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate, const _Ty*>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_COUNT if constexpr (is_same_v<_Pj, identity> && _Vector_alg_in_find_is_safe<_It, _Ty> && sized_sentinel_for<_Se, _It>) { if (!_STD is_constant_evaluated()) { @@ -836,7 +891,7 @@ namespace ranges { return static_cast>(_STD _Count_vectorized(_First_ptr, _Last_ptr, _Val)); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_COUNT ^^^ iter_difference_t<_It> _Count = 0; for (; _First != _Last; ++_First) { @@ -924,7 +979,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InI auto _UFirst1 = _STD _Get_unwrapped(_First1); const auto _ULast1 = _STD _Get_unwrapped(_Last1); auto _UFirst2 = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1)); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH if constexpr (_Equal_memcmp_is_safe) { if (!_STD _Is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>); @@ -940,7 +995,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InI return {_First1, _First2}; } } -#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ _VECTORIZED_MISMATCH ^^^ while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) { ++_UFirst1; ++_UFirst2; @@ -988,7 +1043,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch( const _CT _Count2 = _ULast2 - _UFirst2; const auto _Count = static_cast<_Iter_diff_t<_InIt1>>((_STD min) (_Count1, _Count2)); _ULast1 = _UFirst1 + _Count; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH if constexpr (_Equal_memcmp_is_safe) { if (!_STD _Is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>); @@ -1004,7 +1059,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch( return {_First1, _First2}; } } -#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ _VECTORIZED_MISMATCH ^^^ while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) { ++_UFirst1; ++_UFirst2; @@ -2354,7 +2409,7 @@ _NODISCARD _CONSTEXPR20 _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHays if constexpr (_Is_ranges_random_iter_v<_FwdItHaystack> && _Is_ranges_random_iter_v<_FwdItPat>) { const _Iter_diff_t<_FwdItPat> _Count2 = _ULast2 - _UFirst2; if (_ULast1 - _UFirst1 >= _Count2) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH if constexpr (_Vector_alg_in_search_is_safe) { if (!_STD _Is_constant_evaluated()) { const auto _Ptr1 = _STD _To_address(_UFirst1); @@ -2372,7 +2427,7 @@ _NODISCARD _CONSTEXPR20 _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHays return _Last1; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SEARCH ^^^ const auto _Last_possible = _ULast1 - static_cast<_Iter_diff_t<_FwdItHaystack>>(_Count2); for (;; ++_UFirst1) { @@ -2463,7 +2518,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt search_n( auto _UFirst = _STD _Get_unwrapped(_First); const auto _ULast = _STD _Get_unwrapped(_Last); if constexpr (_Is_ranges_random_iter_v<_FwdIt>) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH_N if constexpr (_Vector_alg_in_search_n_is_safe) { if (!_STD _Is_constant_evaluated()) { if (!_STD _Could_compare_equal_to_value_type(_Val)) { @@ -2484,7 +2539,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt search_n( return _Last; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SEARCH_N ^^^ const auto _Count_diff = static_cast<_Iter_diff_t<_FwdIt>>(_Count); auto _UOld_first = _UFirst; @@ -2658,7 +2713,7 @@ namespace ranges { return {_First, _First}; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH_N if constexpr (_Vector_alg_in_search_n_is_safe<_It, _Ty, _Pr> && is_same_v<_Pj, identity>) { if (!_STD is_constant_evaluated()) { if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) { @@ -2688,7 +2743,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SEARCH_N ^^^ auto _Last = _RANGES next(_First, _Count); auto _Mid1 = _First; @@ -3348,7 +3403,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>); _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate, const _Ty*>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_LAST if constexpr (is_same_v<_Pj, identity> && _Vector_alg_in_find_is_safe<_It, _Ty> && sized_sentinel_for<_Se, _It>) { if (!_STD is_constant_evaluated()) { @@ -3369,7 +3424,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_LAST ^^^ if constexpr (_Bidi_common<_It, _Se>) { for (auto _Result = _Last; _Result != _First;) { @@ -3509,7 +3564,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_end( if constexpr (_Is_ranges_random_iter_v<_FwdIt1> && _Is_ranges_random_iter_v<_FwdIt2>) { const _Iter_diff_t<_FwdIt2> _Count2 = _ULast2 - _UFirst2; if (_Count2 > 0 && _Count2 <= _ULast1 - _UFirst1) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_END if constexpr (_Vector_alg_in_search_is_safe) { if (!_STD _Is_constant_evaluated()) { const auto _Ptr1 = _STD _To_address(_UFirst1); @@ -3527,7 +3582,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_end( return _First1; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_END ^^^ for (auto _UCandidate = _ULast1 - static_cast<_Iter_diff_t<_FwdIt1>>(_Count2);; --_UCandidate) { if (_STD _Equal_rev_pred_unchecked(_UCandidate, _UFirst2, _ULast2, _STD _Pass_fn(_Pred))) { @@ -3632,7 +3687,7 @@ namespace ranges { if (_Count2 > 0 && _Count2 <= _Count1) { const auto _Count2_as1 = static_cast>(_Count2); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_END if constexpr (_Vector_alg_in_search_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) { if (!_STD is_constant_evaluated()) { @@ -3659,7 +3714,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_END ^^^ for (auto _Candidate = _First1 + (_Count1 - _Count2_as1);; --_Candidate) { auto _Match_and_mid1 = @@ -3832,7 +3887,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of( } } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_FIRST_OF if constexpr (_Vector_alg_in_search_is_safe) { if (!_STD _Is_constant_evaluated() && _ULast1 - _UFirst1 >= _Threshold_find_first_of) { const auto _First1_ptr = _STD _To_address(_UFirst1); @@ -3848,7 +3903,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of( return _First1; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ for (; _UFirst1 != _ULast1; ++_UFirst1) { for (auto _UMid2 = _UFirst2; _UMid2 != _ULast2; ++_UMid2) { @@ -3936,7 +3991,7 @@ namespace ranges { } } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND_FIRST_OF if constexpr (_Vector_alg_in_search_is_safe<_It1, _It2, _Pr> && sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) { if (!_STD is_constant_evaluated() && _Last1 - _First1 >= _Threshold_find_first_of) { @@ -3958,7 +4013,8 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^ + for (; _First1 != _Last1; ++_First1) { for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2) { if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_Mid2))) { @@ -3995,7 +4051,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>); _STL_INTERNAL_STATIC_ASSERT(indirectly_swappable<_It1, _It2>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SWAP_RANGES using _Elem1 = remove_reference_t>; using _Elem2 = remove_reference_t>; if constexpr (same_as<_Elem1, _Elem2> && _Is_trivially_ranges_swappable_v<_Elem1> // @@ -4028,7 +4084,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SWAP_RANGES ^^^ for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2) { _RANGES iter_swap(_First1, _First2); @@ -4331,7 +4387,7 @@ _CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _O auto _UFirst = _STD _Get_unwrapped(_First); const auto _ULast = _STD _Get_unwrapped(_Last); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REPLACE if constexpr (_Vector_alg_in_replace_is_safe) { #if _HAS_CXX20 if (!_STD is_constant_evaluated()) @@ -4344,7 +4400,7 @@ _CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _O return; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REPLACE ^^^ for (; _UFirst != _ULast; ++_UFirst) { if (*_UFirst == _Oldval) { @@ -4399,7 +4455,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(indirectly_writable<_It, const _Ty2&>); _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate, const _Ty1*>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REPLACE if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It> && _Vector_alg_in_ranges_replace_is_safe<_It, _Ty1, _Ty2>) { if (!_STD is_constant_evaluated()) { @@ -4414,7 +4470,7 @@ namespace ranges { return _First + _Count; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REPLACE ^^^ for (; _First != _Last; ++_First) { if (_STD invoke(_Proj, *_First) == _Oldval) { @@ -4893,7 +4949,7 @@ _CONSTEXPR20 _OutIt remove_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _ const auto _ULast = _STD _Get_unwrapped(_Last); auto _UDest = _STD _Get_unwrapped_unverified(_Dest); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REMOVE_COPY if constexpr (_Vector_alg_in_find_is_safe && _Output_iterator_for_vector_alg_is_safe()) { if (!_STD _Is_constant_evaluated()) { @@ -4917,7 +4973,7 @@ _CONSTEXPR20 _OutIt remove_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _ return _Dest; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^ for (; _UFirst != _ULast; ++_UFirst) { if (!(*_UFirst == _Val)) { @@ -5016,7 +5072,7 @@ namespace ranges { return {_STD move(_Next), _STD move(_First)}; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REMOVE if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty> && sized_sentinel_for<_Se, _It> && is_same_v<_Pj, identity>) { if (!_STD is_constant_evaluated()) { @@ -5032,7 +5088,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REMOVE ^^^ while (++_First != _Last) { if (_STD invoke(_Proj, *_First) != _Val) { @@ -5144,7 +5200,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>); _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate, const _Ty*>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REMOVE_COPY if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty> && _Output_iterator_for_vector_alg_is_safe<_Out, _It>() && sized_sentinel_for<_Se, _It> && is_same_v<_Pj, identity>) { if (!_STD is_constant_evaluated()) { @@ -5168,7 +5224,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^ for (; _First != _Last; ++_First) { if (_STD invoke(_Proj, *_First) != _Val) { @@ -5251,7 +5307,7 @@ _NODISCARD_UNIQUE_ALG _CONSTEXPR20 _FwdIt unique(_FwdIt _First, _FwdIt _Last, _P auto _UFirst = _STD _Get_unwrapped(_First); const auto _ULast = _STD _Get_unwrapped(_Last); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_UNIQUE if constexpr (_Vector_alg_in_unique_is_safe) { if (!_STD _Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_UFirst); @@ -5267,7 +5323,7 @@ _NODISCARD_UNIQUE_ALG _CONSTEXPR20 _FwdIt unique(_FwdIt _First, _FwdIt _Last, _P return _Last; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_UNIQUE ^^^ if (_UFirst != _ULast) { for (auto _UFirstb = _UFirst; ++_UFirst != _ULast; _UFirstb = _UFirst) { @@ -5345,7 +5401,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>); _STL_INTERNAL_STATIC_ASSERT(indirect_equivalence_relation<_Pr, projected<_It, _Pj>>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_UNIQUE if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It> && _Vector_alg_in_unique_is_safe<_It, _Pr>) { if (!_STD is_constant_evaluated()) { @@ -5361,7 +5417,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_UNIQUE ^^^ auto _Current = _First; if (_First == _Last) { @@ -5417,7 +5473,7 @@ _CONSTEXPR20 _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pr auto _UDest = _STD _Get_unwrapped_unverified(_Dest); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_UNIQUE_COPY if constexpr (_Vector_alg_in_unique_is_safe && _Output_iterator_for_vector_alg_is_safe()) { if (!_STD _Is_constant_evaluated()) { @@ -5435,7 +5491,7 @@ _CONSTEXPR20 _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pr return _Dest; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^ if constexpr (_Is_ranges_fwd_iter_v<_InIt>) { // can reread the source for comparison auto _Firstb = _UFirst; @@ -5564,7 +5620,7 @@ namespace ranges { return {_STD move(_First), _STD move(_Output)}; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_UNIQUE_COPY if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It> && _Vector_alg_in_unique_is_safe<_It, _Pr> && _Output_iterator_for_vector_alg_is_safe<_Out, _It>()) { @@ -5583,7 +5639,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^ if constexpr (_Is_input_with_value_type<_Out, iter_value_t<_It>>) { // Can reread _Output @@ -5632,7 +5688,7 @@ namespace ranges { template requires permutable<_It> constexpr void _Reverse_common(_It _First, _It _Last) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REVERSE if constexpr (contiguous_iterator<_It>) { using _Elem = remove_reference_t>; constexpr size_t _Nx = sizeof(_Elem); @@ -5646,7 +5702,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REVERSE ^^^ for (; _First != _Last && _First != --_Last; ++_First) { _RANGES iter_swap(_First, _Last); @@ -5692,7 +5748,7 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) { auto _ULast = _STD _Get_unwrapped(_Last); auto _UDest = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_BidIt>(_UFirst, _ULast)); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REVERSE_COPY using _Elem = remove_reference_t<_Iter_ref_t>>; using _DestElem = remove_reference_t<_Iter_ref_t>; constexpr bool _Allow_vectorization = conjunction_v, _DestElem>, @@ -5712,7 +5768,7 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) { return _Dest; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^ for (; _UFirst != _ULast; ++_UDest) { *_UDest = *--_ULast; @@ -5781,7 +5837,7 @@ namespace ranges { _STD _Verify_ranges_do_not_overlap(_First, _Last, _Output); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REVERSE_COPY if constexpr (contiguous_iterator<_It> && contiguous_iterator<_Out>) { using _Elem = remove_reference_t>; using _DestElem = remove_reference_t>; @@ -5798,7 +5854,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^ for (; _First != _Last; ++_Output) { *_Output = *--_Last; @@ -5843,7 +5899,7 @@ namespace ranges { } if constexpr (bidirectional_iterator<_It>) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_ROTATE using _Elem = remove_reference_t>; if constexpr (contiguous_iterator<_It> && sized_sentinel_for<_Se, _It> @@ -5854,7 +5910,7 @@ namespace ranges { return {_First + (_Last - _Mid), _Last}; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_ROTATE ^^^ _RANGES _Reverse_common(_First, _Mid); auto _Final = _RANGES _Get_final_iterator_unwrapped<_It>(_Mid, _STD move(_Last)); @@ -8480,7 +8536,7 @@ namespace ranges { return _First; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_IS_SORTED_UNTIL if constexpr (_Is_min_max_iterators_safe<_It> && sized_sentinel_for<_Se, _It> && is_same_v<_Pj, identity>) { constexpr bool _Is_greater = _Is_predicate_greater<_It, _Pr>; if constexpr (_Is_greater || _Is_predicate_less<_It, _Pr>) { @@ -8497,7 +8553,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^ for (auto _Prev = _First; ++_First != _Last; ++_Prev) { if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Prev))) { @@ -10310,14 +10366,14 @@ _NODISCARD _CONSTEXPR20 bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _Fir return false; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_INCLUDES if constexpr (_Vector_alg_includes_iterators_safe<_InIt1, _InIt2> && _Is_predicate_less<_InIt1, _Pr>) { if (!_STD _Is_constant_evaluated()) { return _STD _Includes_vectorized(_STD _To_address(_First1), _STD _To_address(_Last1), _STD _To_address(_First2), _STD _To_address(_Last2)); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_INCLUDES ^^^ for (;;) { if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) { @@ -10408,7 +10464,7 @@ namespace ranges { return false; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_INCLUDES if constexpr (_Vector_alg_includes_iterators_safe<_It1, _It2> && _Is_predicate_less<_It1, _Pr> && sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) { @@ -10420,7 +10476,7 @@ namespace ranges { return _STD _Includes_vectorized(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_INCLUDES ^^^ for (;;) { if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) { @@ -11008,7 +11064,7 @@ namespace ranges { template constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX_ELEMENT if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); @@ -11021,7 +11077,7 @@ constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _ } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ // find smallest and largest elements pair<_FwdIt, _FwdIt> _Found(_First, _First); @@ -11134,7 +11190,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>); _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX_ELEMENT if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr> && sized_sentinel_for<_Se, _It>) { if (!_STD is_constant_evaluated()) { @@ -11149,7 +11205,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ min_max_result<_It> _Found{_First, _First}; @@ -11216,14 +11272,14 @@ _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pr // return {leftmost/smallest, rightmost/largest} _STL_ASSERT( _Ilist.size() != 0, "An initializer_list passed to std::minmax must not be empty. (N4971 [alg.min.max]/21)"); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX if constexpr (_Is_min_max_value_optimization_safe) { if (!_STD _Is_constant_evaluated()) { const auto _Result = _STD _Minmax_vectorized(_Ilist.begin(), _Ilist.end()); return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)}; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX ^^^ pair _Res = _STD _Minmax_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred)); return pair<_Ty, _Ty>(*_Res.first, *_Res.second); @@ -11274,21 +11330,30 @@ namespace ranges { const auto _Last = _Range.end(); _STL_ASSERT(_First != _Last, "An initializer_list passed to std::ranges::minmax must not be empty. (N4971 [alg.min.max]/21)"); -#if _USE_STD_VECTOR_ALGORITHMS + +#if _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT if constexpr (is_same_v<_Pj, identity>) { +#if _VECTORIZED_MINMAX if constexpr (_Is_min_max_value_optimization_safe) { if (!_STD is_constant_evaluated()) { const auto _Result = _STD _Minmax_vectorized(_First, _Last); return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)}; } - } else if constexpr (_Is_min_max_optimization_safe) { - if (!_STD is_constant_evaluated()) { - const auto _Result = _STD _Minmax_element_vectorized(_First, _Last); - return {*static_cast(_Result.first), *static_cast(_Result.second)}; + } else +#endif // ^^^ _VECTORIZED_MINMAX ^^^ + { +#if _VECTORIZED_MINMAX_ELEMENT + if constexpr (_Is_min_max_optimization_safe) { + if (!_STD is_constant_evaluated()) { + const auto _Result = _STD _Minmax_element_vectorized(_First, _Last); + return {*static_cast(_Result.first), *static_cast(_Result.second)}; + } } +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT ^^^ + return _Minmax_fwd_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)); } @@ -11302,8 +11367,10 @@ namespace ranges { _STL_ASSERT( _UFirst != _ULast, "A range passed to std::ranges::minmax must not be empty. (N4971 [alg.min.max]/21)"); using _Vty = range_value_t<_Rng>; -#if _USE_STD_VECTOR_ALGORITHMS + +#if _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for) { +#if _VECTORIZED_MINMAX if constexpr (_Is_min_max_value_optimization_safe) { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_UFirst); @@ -11311,16 +11378,24 @@ namespace ranges { const auto _Result = _STD _Minmax_vectorized(_First_ptr, _Last_ptr); return {static_cast<_Vty>(_Result._Min), static_cast<_Vty>(_Result._Max)}; } - } else if constexpr (_Is_min_max_optimization_safe) { - if (!_STD is_constant_evaluated()) { - const auto _First_ptr = _STD to_address(_UFirst); - const auto _Last_ptr = _First_ptr + static_cast(_ULast - _UFirst); - const auto _Result = _STD _Minmax_element_vectorized(_First_ptr, _Last_ptr); - return {*static_cast(_Result.first), *static_cast(_Result.second)}; + } else +#endif // ^^^ _VECTORIZED_MINMAX ^^^ + { +#if _VECTORIZED_MINMAX_ELEMENT + if constexpr (_Is_min_max_optimization_safe) { + if (!_STD is_constant_evaluated()) { + const auto _First_ptr = _STD to_address(_UFirst); + const auto _Last_ptr = _First_ptr + static_cast(_ULast - _UFirst); + const auto _Result = _STD _Minmax_element_vectorized(_First_ptr, _Last_ptr); + return { + *static_cast(_Result.first), *static_cast(_Result.second)}; + } } +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT ^^^ + if constexpr (forward_range<_Rng> && _Prefer_iterator_copies) { return _Minmax_fwd_unchecked( _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)); @@ -11648,7 +11723,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt is_sorted_until(const _FwdIt _First, _FwdIt _Last auto _UFirst = _STD _Get_unwrapped(_First); auto _ULast = _STD _Get_unwrapped(_Last); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_IS_SORTED_UNTIL if constexpr (_Is_min_max_iterators_safe) { constexpr bool _Is_greater = _Is_predicate_greater; if constexpr (_Is_greater || _Is_predicate_less) { @@ -11668,7 +11743,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt is_sorted_until(const _FwdIt _First, _FwdIt _Last } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^ if (_UFirst != _ULast) { for (auto _UNext = _UFirst; ++_UNext != _ULast; ++_UFirst) { @@ -11901,7 +11976,7 @@ namespace ranges { } const size_t _Num = (_STD min) (_Num1, _Num2); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH const auto _First1_ptr = _STD to_address(_First1); const auto _First2_ptr = _STD to_address(_First2); const size_t _Pos = _Mismatch_vectorized(_First1_ptr, _First2_ptr, _Num); @@ -11912,10 +11987,10 @@ namespace ranges { } else { return _STD invoke(_Pred, _First1_ptr[_Pos], _First2_ptr[_Pos]); } -#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv +#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv const int _Ans = _STD _Memcmp_count(_First1, _First2, _Num); return _Memcmp_classification_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2); -#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ !_VECTORIZED_MISMATCH ^^^ } } diff --git a/stl/inc/bitset b/stl/inc/bitset index 372f8784018..13ed3252884 100644 --- a/stl/inc/bitset +++ b/stl/inc/bitset @@ -22,22 +22,26 @@ _STL_DISABLE_CLANG_WARNINGS #define _STD_BITSET_TO_STREAM_STACK_RESERVATION 128 #endif // !defined(_STD_BITSET_TO_STREAM_STACK_RESERVATION) -#if _USE_STD_VECTOR_ALGORITHMS +extern "C" { // These bitset functions sometimes assume that the bit array has zero padding to a multiple of 2 or 4 bytes. // The assumptions hold true even for the vNext suggestion to use smaller types for small bitsets (see GH-1498) // due to vectorization thresholds. -extern "C" { +#if _VECTORIZED_BITSET_TO_STRING __declspec(noalias) void __stdcall __std_bitset_to_string_1( char* _Dest, const void* _Src, size_t _Size_bits, char _Elem0, char _Elem1) noexcept; __declspec(noalias) void __stdcall __std_bitset_to_string_2( wchar_t* _Dest, const void* _Src, size_t _Size_bits, wchar_t _Elem0, wchar_t _Elem1) noexcept; +#endif // ^^^ _VECTORIZED_BITSET_TO_STRING ^^^ + +#if _VECTORIZED_BITSET_FROM_STRING __declspec(noalias) bool __stdcall __std_bitset_from_string_1(void* _Dest, const char* _Src, size_t _Size_bytes, size_t _Size_bits, size_t _Size_chars, char _Elem0, char _Elem1) noexcept; __declspec(noalias) bool __stdcall __std_bitset_from_string_2(void* _Dest, const wchar_t* _Src, size_t _Size_bytes, size_t _Size_bits, size_t _Size_chars, wchar_t _Elem0, wchar_t _Elem1) noexcept; +#endif // ^^^ _VECTORIZED_BITSET_FROM_STRING ^^^ + } // extern "C" -#endif // _USE_STD_VECTOR_ALGORITHMS _STD_BEGIN template _STD_BITSET_TO_STREAM_STACK_RESERVATION)> @@ -147,7 +151,7 @@ public: private: template _CONSTEXPR23 void _Construct(const _Elem* const _Ptr, size_t _Count, const _Elem _Elem0, const _Elem _Elem1) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_BITSET_FROM_STRING constexpr size_t _Bitset_from_string_vector_threshold = 16; if constexpr (_Bits >= _Bitset_from_string_vector_threshold && _Is_implementation_handled_char_traits<_Traits> && sizeof(_Elem) <= 2) { @@ -170,7 +174,8 @@ private: return; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_BITSET_FROM_STRING ^^^ + if (_Count > _Bits) { for (size_t _Idx = _Bits; _Idx < _Count; ++_Idx) { const auto _Ch = _Ptr[_Idx]; @@ -516,7 +521,7 @@ public: template _CONSTEXPR23 void _To_string( _Elem* const _Buf, const size_t _Len, const _Elem _Elem0, const _Elem _Elem1) const noexcept { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_BITSET_TO_STRING constexpr size_t _Bitset_to_string_vector_threshold = 32; if constexpr (_Bits >= _Bitset_to_string_vector_threshold && is_integral_v<_Elem> && sizeof(_Elem) <= 2) { if (!_Is_constant_evaluated()) { @@ -532,7 +537,7 @@ public: return; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_BITSET_TO_STRING ^^^ for (size_t _Pos = 0; _Pos < _Len; ++_Pos) { _Buf[_Pos] = _Subscript(_Len - 1 - _Pos) ? _Elem1 : _Elem0; diff --git a/stl/inc/functional b/stl/inc/functional index 48feddd89c4..0643a4a4aaa 100644 --- a/stl/inc/functional +++ b/stl/inc/functional @@ -2556,7 +2556,7 @@ _CONSTEXPR20 pair<_FwdItHaystack, _FwdItHaystack> _Search_pair_unchecked( _Iter_diff_t<_FwdItHaystack> _Count1 = _Last1 - _First1; _Iter_diff_t<_FwdItPat> _Count2 = _Last2 - _First2; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH if constexpr (_Vector_alg_in_search_is_safe<_FwdItHaystack, _FwdItPat, _Pred_eq>) { if (!_STD _Is_constant_evaluated()) { const auto _Ptr1 = _STD _To_address(_First1); @@ -2577,7 +2577,7 @@ _CONSTEXPR20 pair<_FwdItHaystack, _FwdItHaystack> _Search_pair_unchecked( } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SEARCH ^^^ for (; _Count2 <= _Count1; ++_First1, (void) --_Count1) { // room for match, try it _FwdItHaystack _Mid1 = _First1; diff --git a/stl/inc/xmemory b/stl/inc/xmemory index 5305b74b45a..c73653f10be 100644 --- a/stl/inc/xmemory +++ b/stl/inc/xmemory @@ -31,7 +31,7 @@ _STL_DISABLE_CLANG_WARNINGS #undef msvc #undef no_specializations -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REMOVE extern "C" { void* __stdcall __std_remove_1(void* _First, void* _Last, uint8_t _Val) noexcept; void* __stdcall __std_remove_2(void* _First, void* _Last, uint16_t _Val) noexcept; @@ -56,7 +56,7 @@ _Ty* _Remove_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) n } _STD_END -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REMOVE ^^^ _STD_BEGIN template @@ -2330,7 +2330,7 @@ _NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove(_FwdIt _First, const _FwdIt _La _UFirst = _STD _Find_unchecked(_UFirst, _ULast, _Val); auto _UNext = _UFirst; if (_UFirst != _ULast) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REMOVE if constexpr (_Vector_alg_in_find_is_safe) { #if _HAS_CXX20 if (!_STD is_constant_evaluated()) @@ -2349,7 +2349,7 @@ _NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove(_FwdIt _First, const _FwdIt _La return _First; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REMOVE ^^^ while (++_UFirst != _ULast) { if (!(*_UFirst == _Val)) { diff --git a/stl/inc/xutility b/stl/inc/xutility index 935ced63c13..da3e663bdec 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -41,17 +41,68 @@ _STL_DISABLE_CLANG_WARNINGS #elif _USE_STD_VECTOR_ALGORITHMS #error Vector algorithms are not supported when building msvcp140.dll, but _USE_STD_VECTOR_ALGORITHMS is set. #endif // ^^^ _USE_STD_VECTOR_ALGORITHMS != 0 ^^^ -#elif (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE) && !defined(_M_HYBRID) && !defined(_M_ARM64EC) -#ifndef _USE_STD_VECTOR_ALGORITHMS -#define _USE_STD_VECTOR_ALGORITHMS 1 -#endif // !defined(_USE_STD_VECTOR_ALGORITHMS) -#else // ^^^ arch supports vector algorithms / no support for vector algorithms vvv +#elif defined(_M_CEE_PURE) || defined(_M_HYBRID) #ifndef _USE_STD_VECTOR_ALGORITHMS #define _USE_STD_VECTOR_ALGORITHMS 0 #elif _USE_STD_VECTOR_ALGORITHMS #error Vector algorithms are not supported on this architecture, but _USE_STD_VECTOR_ALGORITHMS is set. #endif // ^^^ _USE_STD_VECTOR_ALGORITHMS != 0 ^^^ -#endif // ^^^ no support for vector algorithms ^^^ +#else // ^^^ vector algorithms unsupported for /clr:pure or CHPE / vector algorithms supported by default vvv +#ifndef _USE_STD_VECTOR_ALGORITHMS +#define _USE_STD_VECTOR_ALGORITHMS 1 +#endif // !defined(_USE_STD_VECTOR_ALGORITHMS) +#endif // ^^^ vector algorithms supported by default ^^^ + +// _USE_STD_VECTOR_ALGORITHMS is our documented control macro: +// https://learn.microsoft.com/en-us/cpp/standard-library/vectorized-stl-algorithms?view=msvc-170 +// In the STL's implementation, we inspect the following detection macros, +// because various algorithms are vectorized for various architectures. + +#if !_USE_STD_VECTOR_ALGORITHMS +#define _VECTORIZED_FOR_X64_X86 0 +#define _VECTORIZED_FOR_X64_X86_ARM64 0 +#define _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC 0 +#elif defined(_M_ARM64EC) +#define _VECTORIZED_FOR_X64_X86 0 +#define _VECTORIZED_FOR_X64_X86_ARM64 0 +#define _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC 1 +#elif defined(_M_ARM64) +#define _VECTORIZED_FOR_X64_X86 0 +#define _VECTORIZED_FOR_X64_X86_ARM64 1 +#define _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC 1 +#elif defined(_M_X64) || defined(_M_IX86) +#define _VECTORIZED_FOR_X64_X86 1 +#define _VECTORIZED_FOR_X64_X86_ARM64 1 +#define _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC 1 +#else // ^^^ known architecture / unknown architecture vvv +#error Unknown architecture. +#endif // ^^^ unknown architecture ^^^ + +#define _VECTORIZED_ADJACENT_FIND _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_BITSET_FROM_STRING _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_BITSET_TO_STRING _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_COUNT _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_FIND _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_FIND_END _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_FIND_FIRST_OF _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_FIND_LAST _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_FIND_LAST_OF _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_INCLUDES _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_IS_SORTED_UNTIL _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_MINMAX _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_MINMAX_ELEMENT _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_MISMATCH _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_REMOVE _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_REMOVE_COPY _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_REPLACE _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_REVERSE _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_REVERSE_COPY _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_ROTATE _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_SEARCH _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_SEARCH_N _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_SWAP_RANGES _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_UNIQUE _VECTORIZED_FOR_X64_X86 +#define _VECTORIZED_UNIQUE_COPY _VECTORIZED_FOR_X64_X86 #ifndef _USE_STD_VECTOR_FLOATING_ALGORITHMS #if _USE_STD_VECTOR_ALGORITHMS && !defined(_M_FP_EXCEPT) @@ -73,7 +124,6 @@ _STL_DISABLE_CLANG_WARNINGS #endif // ^^^ !defined(__clang__) || __clang_major__ < 19 ^^^ #endif // ^^^ !defined(_USE_BUILTIN_IS_TRIVIALLY_EQUALITY_COMPARABLE) ^^^ -#if _USE_STD_VECTOR_ALGORITHMS extern "C" { // The "noalias" attribute tells the compiler optimizer that pointers going into these hand-vectorized algorithms // won't be stored beyond the lifetime of the function, and that the function will only reference arrays denoted by @@ -82,15 +132,24 @@ extern "C" { // functions are in native code objects that the compiler cannot analyze. In the absence of the noalias attribute, the // compiler has to assume that the denoted arrays are "globally address taken", and that any later calls to // unanalyzable routines may modify those arrays. + +#if _VECTORIZED_REVERSE __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_1(void* _First, void* _Last) noexcept; __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_2(void* _First, void* _Last) noexcept; __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_4(void* _First, void* _Last) noexcept; __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_8(void* _First, void* _Last) noexcept; +#endif // ^^^ _VECTORIZED_REVERSE ^^^ + +#if _VECTORIZED_SWAP_RANGES __declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias( void* _First1, void* _Last1, void* _First2) noexcept; +#endif // ^^^ _VECTORIZED_SWAP_RANGES ^^^ +#if _VECTORIZED_ROTATE __declspec(noalias) void __stdcall __std_rotate(void* _First, void* _Mid, void* _Last) noexcept; +#endif // ^^^ _VECTORIZED_ROTATE ^^^ +#if _VECTORIZED_COUNT __declspec(noalias) size_t __stdcall __std_count_trivial_1( const void* _First, const void* _Last, uint8_t _Val) noexcept; __declspec(noalias) size_t __stdcall __std_count_trivial_2( @@ -99,22 +158,30 @@ __declspec(noalias) size_t __stdcall __std_count_trivial_4( const void* _First, const void* _Last, uint32_t _Val) noexcept; __declspec(noalias) size_t __stdcall __std_count_trivial_8( const void* _First, const void* _Last, uint64_t _Val) noexcept; +#endif // ^^^ _VECTORIZED_COUNT ^^^ +#if _VECTORIZED_FIND const void* __stdcall __std_find_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept; const void* __stdcall __std_find_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept; const void* __stdcall __std_find_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept; const void* __stdcall __std_find_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept; +#endif // ^^^ _VECTORIZED_FIND ^^^ +#if _VECTORIZED_FIND_LAST const void* __stdcall __std_find_last_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept; const void* __stdcall __std_find_last_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept; const void* __stdcall __std_find_last_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept; const void* __stdcall __std_find_last_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept; +#endif // ^^^ _VECTORIZED_FIND_LAST ^^^ +#if _VECTORIZED_ADJACENT_FIND const void* __stdcall __std_adjacent_find_1(const void* _First, const void* _Last) noexcept; const void* __stdcall __std_adjacent_find_2(const void* _First, const void* _Last) noexcept; const void* __stdcall __std_adjacent_find_4(const void* _First, const void* _Last) noexcept; const void* __stdcall __std_adjacent_find_8(const void* _First, const void* _Last) noexcept; +#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^ +#if _VECTORIZED_SEARCH const void* __stdcall __std_search_1( const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept; const void* __stdcall __std_search_2( @@ -123,7 +190,9 @@ const void* __stdcall __std_search_4( const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept; const void* __stdcall __std_search_8( const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept; +#endif // ^^^ _VECTORIZED_SEARCH ^^^ +#if _VECTORIZED_FIND_END const void* __stdcall __std_find_end_1( const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept; const void* __stdcall __std_find_end_2( @@ -132,8 +201,9 @@ const void* __stdcall __std_find_end_4( const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept; const void* __stdcall __std_find_end_8( const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept; +#endif // ^^^ _VECTORIZED_FIND_END ^^^ - +#if _VECTORIZED_MINMAX_ELEMENT const void* __stdcall __std_min_element_1(const void* _First, const void* _Last, bool _Signed) noexcept; const void* __stdcall __std_min_element_2(const void* _First, const void* _Last, bool _Signed) noexcept; const void* __stdcall __std_min_element_4(const void* _First, const void* _Last, bool _Signed) noexcept; @@ -147,7 +217,9 @@ const void* __stdcall __std_max_element_4(const void* _First, const void* _Last, const void* __stdcall __std_max_element_8(const void* _First, const void* _Last, bool _Signed) noexcept; const void* __stdcall __std_max_element_f(const void* _First, const void* _Last, bool _Unused) noexcept; const void* __stdcall __std_max_element_d(const void* _First, const void* _Last, bool _Unused) noexcept; +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ +#if _VECTORIZED_MINMAX __declspec(noalias) int8_t __stdcall __std_min_1i(const void* _First, const void* _Last) noexcept; __declspec(noalias) uint8_t __stdcall __std_min_1u(const void* _First, const void* _Last) noexcept; __declspec(noalias) int16_t __stdcall __std_min_2i(const void* _First, const void* _Last) noexcept; @@ -158,6 +230,7 @@ __declspec(noalias) int64_t __stdcall __std_min_8i(const void* _First, const voi __declspec(noalias) uint64_t __stdcall __std_min_8u(const void* _First, const void* _Last) noexcept; __declspec(noalias) float __stdcall __std_min_f(const void* _First, const void* _Last) noexcept; __declspec(noalias) double __stdcall __std_min_d(const void* _First, const void* _Last) noexcept; + __declspec(noalias) int8_t __stdcall __std_max_1i(const void* _First, const void* _Last) noexcept; __declspec(noalias) uint8_t __stdcall __std_max_1u(const void* _First, const void* _Last) noexcept; __declspec(noalias) int16_t __stdcall __std_max_2i(const void* _First, const void* _Last) noexcept; @@ -168,13 +241,16 @@ __declspec(noalias) int64_t __stdcall __std_max_8i(const void* _First, const voi __declspec(noalias) uint64_t __stdcall __std_max_8u(const void* _First, const void* _Last) noexcept; __declspec(noalias) float __stdcall __std_max_f(const void* _First, const void* _Last) noexcept; __declspec(noalias) double __stdcall __std_max_d(const void* _First, const void* _Last) noexcept; +#endif // ^^^ _VECTORIZED_MINMAX ^^^ +#if _VECTORIZED_MISMATCH __declspec(noalias) size_t __stdcall __std_mismatch_1(const void* _First1, const void* _First2, size_t _Count) noexcept; __declspec(noalias) size_t __stdcall __std_mismatch_2(const void* _First1, const void* _First2, size_t _Count) noexcept; __declspec(noalias) size_t __stdcall __std_mismatch_4(const void* _First1, const void* _First2, size_t _Count) noexcept; __declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const void* _First2, size_t _Count) noexcept; +#endif // ^^^ _VECTORIZED_MISMATCH ^^^ + } // extern "C" -#endif // _USE_STD_VECTOR_ALGORITHMS _STD_BEGIN @@ -187,7 +263,7 @@ _Target _Find_arg_cast(const _Source _Val) noexcept { } } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REVERSE template __declspec(noalias) void _Reverse_vectorized(void* _First, void* _Last) noexcept { if constexpr (_Nx == 1) { @@ -202,7 +278,9 @@ __declspec(noalias) void _Reverse_vectorized(void* _First, void* _Last) noexcept _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_REVERSE ^^^ +#if _VECTORIZED_COUNT template __declspec(noalias) size_t _Count_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -217,7 +295,9 @@ __declspec(noalias) size_t _Count_vectorized(_Ty* const _First, _Ty* const _Last _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_COUNT ^^^ +#if _VECTORIZED_FIND template _Ty* _Find_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -236,7 +316,9 @@ _Ty* _Find_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noe _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND ^^^ +#if _VECTORIZED_FIND_LAST template _Ty* _Find_last_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -255,7 +337,9 @@ _Ty* _Find_last_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_LAST ^^^ +#if _VECTORIZED_ADJACENT_FIND template _Ty* _Adjacent_find_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { if constexpr (sizeof(_Ty) == 1) { @@ -270,10 +354,16 @@ _Ty* _Adjacent_find_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^ +#if _VECTORIZED_FIND_FIRST_OF || _VECTORIZED_FIND_LAST_OF // find_first_of vectorization is likely to be a win after this size (in elements) +// (Used with _Find_first_of_vectorized, _Find_first_of_pos_vectorized, _Find_first_not_of_pos_vectorized, +// _Find_last_of_pos_vectorized, and _Find_last_not_of_pos_vectorized.) _INLINE_VAR constexpr ptrdiff_t _Threshold_find_first_of = 16; +#endif // ^^^ _VECTORIZED_FIND_FIRST_OF || _VECTORIZED_FIND_LAST_OF ^^^ +#if _VECTORIZED_SEARCH template _Ty1* _Search_vectorized(_Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, const size_t _Count2) noexcept { _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2)); @@ -289,7 +379,9 @@ _Ty1* _Search_vectorized(_Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _F _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_SEARCH ^^^ +#if _VECTORIZED_FIND_END template _Ty1* _Find_end_vectorized( _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, const size_t _Count2) noexcept { @@ -306,7 +398,9 @@ _Ty1* _Find_end_vectorized( _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_FIND_END ^^^ +#if _VECTORIZED_MINMAX_ELEMENT template _Ty* _Min_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; @@ -348,7 +442,9 @@ _Ty* _Max_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ +#if _VECTORIZED_MINMAX template auto _Min_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; @@ -434,7 +530,9 @@ auto _Max_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size } } +#endif // ^^^ _VECTORIZED_MINMAX ^^^ +#if _VECTORIZED_MISMATCH template size_t _Mismatch_vectorized(const void* const _First1, const void* const _First2, const size_t _Count) noexcept { if constexpr (_Element_size % 8 == 0) { @@ -447,7 +545,7 @@ size_t _Mismatch_vectorized(const void* const _First1, const void* const _First2 return __std_mismatch_1(_First1, _First2, _Count * _Element_size) / _Element_size; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MISMATCH ^^^ template struct _Get_first_parameter; @@ -5595,15 +5693,17 @@ template constexpr bool _Equal_memcmp_is_safe = _Equal_memcmp_is_safe_helper, remove_const_t<_Iter2>, remove_const_t<_Pr>>; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH || _VECTORIZED_ADJACENT_FIND || _VECTORIZED_FIND_END || _VECTORIZED_FIND_FIRST_OF \ + || _VECTORIZED_UNIQUE || _VECTORIZED_UNIQUE_COPY template constexpr bool _Is_vector_element_size = _Size == 1 || _Size == 2 || _Size == 4 || _Size == 8; -// Can we activate the vector algorithms for std::search? +// Can we activate the vector algorithms for search, adjacent_find, find_end, find_first_of, and default_searcher? +// (Also used indirectly for unique and unique_copy.) template constexpr bool _Vector_alg_in_search_is_safe = _Equal_memcmp_is_safe<_It1, _It2, _Pr> && _Is_vector_element_size)>; -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _Vector_alg_in_search_is_safe is available ^^^ template _NODISCARD int _Memcmp_count(_CtgIt1 _First1, _CtgIt2 _First2, const size_t _Count) { @@ -5760,7 +5860,7 @@ namespace ranges { _NODISCARD constexpr mismatch_result<_It1, _It2> _Mismatch_n( _It1 _First1, _It2 _First2, iter_difference_t<_It1> _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) { _STL_INTERNAL_CHECK(_Count >= 0); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH if constexpr (_Equal_memcmp_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) { if (!_STD is_constant_evaluated()) { @@ -5773,7 +5873,7 @@ namespace ranges { _First2 + static_cast>(_Pos)}; } } -#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ _VECTORIZED_MISMATCH ^^^ for (; _Count != 0; ++_First1, (void) ++_First2, --_Count) { if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) { break; @@ -5872,13 +5972,13 @@ namespace ranges { template constexpr bool _Lex_compare_memcmp_classify_elements = -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH is_integral_v<_Elem1> && is_integral_v<_Elem2> && sizeof(_Elem1) == sizeof(_Elem2) && is_unsigned_v<_Elem1> == is_unsigned_v<_Elem2>; -#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv +#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv conjunction_v<_Is_character_or_bool<_Elem1>, _Is_character_or_bool<_Elem2>, is_unsigned<_Elem1>, is_unsigned<_Elem2>>; -#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ !_VECTORIZED_MISMATCH ^^^ #ifdef __cpp_lib_byte template <> @@ -5953,7 +6053,7 @@ _NODISCARD _CONSTEXPR20 bool lexicographical_compare( const auto _Num1 = static_cast(_ULast1 - _UFirst1); const auto _Num2 = static_cast(_ULast2 - _UFirst2); const size_t _Num = (_STD min) (_Num1, _Num2); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH const auto _First1_ptr = _STD _To_address(_UFirst1); const auto _First2_ptr = _STD _To_address(_UFirst2); const size_t _Pos = _Mismatch_vectorized(_First1_ptr, _First2_ptr, _Num); @@ -5964,10 +6064,10 @@ _NODISCARD _CONSTEXPR20 bool lexicographical_compare( } else { return _Pred(_First1_ptr[_Pos], _First2_ptr[_Pos]); } -#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv +#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num); return _Memcmp_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2); -#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ !_VECTORIZED_MISMATCH ^^^ } } @@ -6078,7 +6178,7 @@ _NODISCARD constexpr auto lexicographical_compare_three_way(const _InIt1 _First1 const auto _Num1 = static_cast(_ULast1 - _UFirst1); const auto _Num2 = static_cast(_ULast2 - _UFirst2); const size_t _Num = (_STD min) (_Num1, _Num2); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MISMATCH const auto _First1_ptr = _STD to_address(_UFirst1); const auto _First2_ptr = _STD to_address(_UFirst2); const size_t _Pos = _Mismatch_vectorized(_First1_ptr, _First2_ptr, _Num); @@ -6092,14 +6192,14 @@ _NODISCARD constexpr auto lexicographical_compare_three_way(const _InIt1 _First1 __assume(_Val1 != _Val2); // avoid one comparison return _Comp(_Val1, _Val2); } -#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv +#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num); if (_Ans == 0) { return _Num1 <=> _Num2; } else { return _Memcmp_pred{}(_Ans, 0); } -#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ !_VECTORIZED_MISMATCH ^^^ } } @@ -6161,7 +6261,8 @@ constexpr bool _Vector_alg_in_find_is_safe_elem = // - One of the pointer types is a cv1 U* and the other is a cv2 U*. _Vector_alg_in_find_is_safe_object_pointers<_Ty, _Elem>>; -// Can we activate the vector algorithms for find/count? +// Can we activate the vector algorithms for find, count, remove, remove_copy, and ranges::find_last? +// (Also used indirectly for replace and search_n.) template constexpr bool _Vector_alg_in_find_is_safe = // The iterator must be contiguous so we can get raw pointers. @@ -6238,7 +6339,7 @@ _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, c if (!_STD _Could_compare_equal_to_value_type<_InIt>(_Val)) { return _Last; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND const auto _First_ptr = _STD _To_address(_First); const auto _Result = _STD _Find_vectorized(_First_ptr, _STD _To_address(_Last), _Val); if constexpr (is_pointer_v<_InIt>) { @@ -6246,7 +6347,7 @@ _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, c } else { return _First + static_cast<_Iter_diff_t<_InIt>>(_Result - _First_ptr); } -#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv +#else // ^^^ _VECTORIZED_FIND / !_VECTORIZED_FIND vvv if constexpr (sizeof(_Iter_value_t<_InIt>) <= 2) { const auto _First_ptr = _STD _To_address(_First); const auto _Count = static_cast(_Last - _First); @@ -6269,7 +6370,7 @@ _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, c return _Result ? _First + (_Result - _First_ptr) : _Last; } } -#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ !_VECTORIZED_FIND ^^^ } } @@ -6318,7 +6419,7 @@ namespace ranges { if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty> && same_as<_Pj, identity> && (_Elements_are_1_byte ? _Is_sized || same_as<_Se, unreachable_sentinel_t> : _Elements_are_2_bytes ? _Is_sized - : _Is_sized && _USE_STD_VECTOR_ALGORITHMS)) { + : _Is_sized && _VECTORIZED_FIND)) { if (!_STD is_constant_evaluated()) { if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) { if constexpr (_Is_sized) { @@ -6333,13 +6434,13 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); _Ptr_t _Result; -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_FIND if constexpr (_Is_sized) { // Prefer this over memchr()/wmemchr() below for performance const auto _Last_ptr = _First_ptr + static_cast(_Last - _First); _Result = _STD _Find_vectorized(_First_ptr, _Last_ptr, _Val); } else -#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^ +#endif // ^^^ _VECTORIZED_FIND ^^^ { if constexpr (_Elements_are_2_bytes) { _STL_INTERNAL_STATIC_ASSERT(_Is_sized); @@ -6428,7 +6529,7 @@ _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InI auto _UFirst = _STD _Get_unwrapped(_First); const auto _ULast = _STD _Get_unwrapped(_Last); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_COUNT if constexpr (_Vector_alg_in_find_is_safe) { #if _HAS_CXX20 if (!_STD is_constant_evaluated()) @@ -6442,7 +6543,7 @@ _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InI _STD _Count_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val)); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_COUNT ^^^ _Iter_diff_t<_InIt> _Count = 0; @@ -6632,7 +6733,7 @@ _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse _STD _Adl_verify_range(_First, _Last); auto _UFirst = _STD _Get_unwrapped(_First); auto _ULast = _STD _Get_unwrapped(_Last); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_REVERSE using _Elem = remove_reference_t<_Iter_ref_t>; constexpr bool _Allow_vectorization = conjunction_v>, _Is_trivially_swappable<_Elem>, negation>>; @@ -6647,7 +6748,7 @@ _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse return; } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_REVERSE ^^^ for (; _UFirst != _ULast && _UFirst != --_ULast; ++_UFirst) { swap(*_UFirst, *_ULast); // intentional ADL @@ -6694,7 +6795,7 @@ _CONSTEXPR20 _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) { } if constexpr (_Is_cpp17_random_iter_v<_FwdIt>) { -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_ROTATE using _Elem = remove_reference_t<_Iter_ref_t>; if constexpr (conjunction_v>, @@ -6704,7 +6805,7 @@ _CONSTEXPR20 _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) { return _First + (_Last - _Mid); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_ROTATE ^^^ _STD reverse(_UFirst, _UMid); _STD reverse(_UMid, _ULast); _STD reverse(_UFirst, _ULast); @@ -6923,7 +7024,7 @@ namespace ranges { return _First; } -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_ADJACENT_FIND if constexpr (_Vector_alg_in_search_is_safe<_It, _It, _Pr> && sized_sentinel_for<_Se, _It> && is_same_v<_Pj, identity>) { if (!_STD is_constant_evaluated()) { @@ -6938,7 +7039,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^ for (auto _Next = _First;; ++_First) { if (++_Next == _Last) { @@ -7027,7 +7128,7 @@ namespace ranges { _STL_INTERNAL_CHECK(_RANGES distance(_First1, _Last1) == _Count1); _STL_INTERNAL_CHECK(_RANGES distance(_First2, _Last2) == _Count2); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH if constexpr (_Vector_alg_in_search_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) { if (!_STD is_constant_evaluated()) { @@ -7060,7 +7161,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SEARCH ^^^ for (; _Count1 >= _Count2; ++_First1, (void) --_Count1) { auto _Match_and_mid1 = _RANGES _Equal_rev_pred(_First1, _First2, _Last2, _Pred, _Proj1, _Proj2); @@ -7157,7 +7258,7 @@ constexpr bool _Is_min_max_value_optimization_safe = // Activate the vector algo template constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find largest element -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX_ELEMENT if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); @@ -7169,7 +7270,7 @@ constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ _FwdIt _Found = _First; if (_First != _Last) { @@ -7221,7 +7322,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>); _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX_ELEMENT if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr> && sized_sentinel_for<_Se, _It>) { if (!_STD is_constant_evaluated()) { @@ -7235,7 +7336,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ auto _Found = _First; if (_First == _Last) { @@ -7284,13 +7385,13 @@ _NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) { // return leftmost/largest _STL_ASSERT( _Ilist.size() != 0, "An initializer_list passed to std::max must not be empty. (N4971 [alg.min.max]/13)"); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX if constexpr (_Is_min_max_value_optimization_safe) { if (!_Is_constant_evaluated()) { return static_cast<_Ty>(_STD _Max_vectorized(_Ilist.begin(), _Ilist.end())); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX ^^^ const _Ty* _Res = _STD _Max_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred)); return *_Res; } @@ -7330,13 +7431,13 @@ namespace ranges { const auto _Last = _Range.end(); _STL_ASSERT(_First != _Last, "An initializer_list passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)"); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe) { if (!_STD is_constant_evaluated()) { return static_cast<_Ty>(_STD _Max_vectorized(_First, _Last)); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX ^^^ return *_RANGES _Max_element_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)); } @@ -7349,7 +7450,7 @@ namespace ranges { auto _ULast = _Uend(_Range); _STL_ASSERT( _UFirst != _ULast, "A range passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)"); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe && sized_sentinel_for) { if (!_STD is_constant_evaluated()) { @@ -7358,7 +7459,7 @@ namespace ranges { return static_cast>(_STD _Max_vectorized(_First_ptr, _Last_ptr)); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX ^^^ if constexpr (forward_range<_Rng> && _Prefer_iterator_copies) { return static_cast>(*_RANGES _Max_element_unchecked( _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj))); @@ -7381,7 +7482,7 @@ namespace ranges { template constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find smallest element -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX_ELEMENT if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); @@ -7393,7 +7494,7 @@ constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ _FwdIt _Found = _First; if (_First != _Last) { @@ -7445,7 +7546,7 @@ namespace ranges { _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>); _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX_ELEMENT if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr> && sized_sentinel_for<_Se, _It>) { if (!_STD is_constant_evaluated()) { @@ -7459,7 +7560,7 @@ namespace ranges { } } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^ auto _Found = _First; if (_First == _Last) { @@ -7508,13 +7609,13 @@ _NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) { // return leftmost/smallest _STL_ASSERT( _Ilist.size() != 0, "An initializer_list passed to std::min must not be empty. (N4971 [alg.min.max]/5)"); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX if constexpr (_Is_min_max_value_optimization_safe) { if (!_Is_constant_evaluated()) { return static_cast<_Ty>(_STD _Min_vectorized(_Ilist.begin(), _Ilist.end())); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX ^^^ const _Ty* _Res = _STD _Min_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred)); return *_Res; } @@ -7548,13 +7649,13 @@ namespace ranges { const auto _Last = _Range.end(); _STL_ASSERT(_First != _Last, "An initializer_list passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)"); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe) { if (!_STD is_constant_evaluated()) { return static_cast<_Ty>(_STD _Min_vectorized(_First, _Last)); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX ^^^ return *_RANGES _Min_element_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)); } @@ -7567,7 +7668,7 @@ namespace ranges { auto _ULast = _Uend(_Range); _STL_ASSERT( _UFirst != _ULast, "A range passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)"); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_MINMAX if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe && sized_sentinel_for) { if (!_STD is_constant_evaluated()) { @@ -7576,7 +7677,7 @@ namespace ranges { return static_cast>(_STD _Min_vectorized(_First_ptr, _Last_ptr)); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_MINMAX ^^^ if constexpr (forward_range<_Rng> && _Prefer_iterator_copies) { return static_cast>(*_RANGES _Min_element_unchecked( _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj))); @@ -7657,7 +7758,7 @@ template _CONSTEXPR20 _FwdIt2 _Swap_ranges_unchecked(_FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) { // swap [_First1, _Last1) with [_First2, ...) -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SWAP_RANGES using _Elem1 = remove_reference_t<_Iter_ref_t<_FwdIt1>>; using _Elem2 = remove_reference_t<_Iter_ref_t<_FwdIt2>>; if constexpr (is_same_v<_Elem1, _Elem2> && _Is_trivially_swappable_v<_Elem1> @@ -7671,7 +7772,7 @@ _CONSTEXPR20 _FwdIt2 _Swap_ranges_unchecked(_FwdIt1 _First1, const _FwdIt1 _Last return _First2 + (_Last1 - _First1); } } -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _VECTORIZED_SWAP_RANGES ^^^ for (; _First1 != _Last1; ++_First1, (void) ++_First2) { swap(*_First1, *_First2); // intentional ADL diff --git a/tests/std/tests/GH_000431_equal_memcmp_is_safe/test.compile.pass.cpp b/tests/std/tests/GH_000431_equal_memcmp_is_safe/test.compile.pass.cpp index 5dabfa6499b..52bcd932c13 100644 --- a/tests/std/tests/GH_000431_equal_memcmp_is_safe/test.compile.pass.cpp +++ b/tests/std/tests/GH_000431_equal_memcmp_is_safe/test.compile.pass.cpp @@ -529,10 +529,11 @@ STATIC_ASSERT(test_equal_memcmp_is_safe_for_types> == magic); STATIC_ASSERT(_Equal_memcmp_is_safe> == magic); -#if _USE_STD_VECTOR_ALGORITHMS +#if _VECTORIZED_SEARCH || _VECTORIZED_ADJACENT_FIND || _VECTORIZED_FIND_END || _VECTORIZED_FIND_FIRST_OF \ + || _VECTORIZED_UNIQUE || _VECTORIZED_UNIQUE_COPY STATIC_ASSERT(_Vector_alg_in_search_is_safe> == magic); STATIC_ASSERT(!_Vector_alg_in_search_is_safe>); -#endif // _USE_STD_VECTOR_ALGORITHMS +#endif // ^^^ _Vector_alg_in_search_is_safe is available ^^^ #endif // _HAS_CXX20 // Test _Std_char_traits_eq diff --git a/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp b/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp index 85f43c2201c..ea9da34ae0c 100644 --- a/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp +++ b/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp @@ -178,7 +178,7 @@ void test_lex_compare_memcmp_classify_for_types() { #endif // _HAS_CXX20 } -constexpr bool vec_alg = _USE_STD_VECTOR_ALGORITHMS; +constexpr bool vec_alg = _VECTORIZED_MISMATCH; template void test_lex_compare_memcmp_classify_for_1byte_integrals() {