From eb5d5039b8937eb0cf6f6ebd8201b7e2c6158348 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 08:19:56 +0300 Subject: [PATCH 01/27] rename functions --- stl/inc/algorithm | 30 +++++----- stl/inc/xutility | 46 ++++++++-------- stl/src/vector_algorithms.cpp | 100 +++++++++++++++++----------------- 3 files changed, 88 insertions(+), 88 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index ff1f8b65e3..8a2ab3c249 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -77,7 +77,7 @@ __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, cons _STD_BEGIN template -pair<_Ty*, _Ty*> __std_minmax_element(_Ty* const _First, _Ty* const _Last) noexcept { +pair<_Ty*, _Ty*> _Minmax_element(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; _Min_max_element_t _Res; @@ -102,7 +102,7 @@ pair<_Ty*, _Ty*> __std_minmax_element(_Ty* const _First, _Ty* const _Last) noexc } template -auto __std_minmax(_Ty* const _First, _Ty* const _Last) noexcept { +auto _Minmax(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_pointer_v<_Ty>) { @@ -146,9 +146,9 @@ auto __std_minmax(_Ty* const _First, _Ty* const _Last) noexcept { } template -_Ty* __std_find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { +_Ty* _Find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { - return _STD __std_find_last_trivial(_First, _Last, reinterpret_cast(_Val)); + return _STD _Find_last_trivial(_First, _Last, reinterpret_cast(_Val)); } else if constexpr (sizeof(_Ty) == 1) { return const_cast<_Ty*>( static_cast(::__std_find_last_trivial_1(_First, _Last, static_cast(_Val)))); @@ -167,7 +167,7 @@ _Ty* __std_find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _V } template -_Ty1* __std_find_first_of_trivial( +_Ty1* _Find_first_of_trivial( _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept { if constexpr (sizeof(_Ty1) == 1) { return const_cast<_Ty1*>( @@ -578,7 +578,7 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - return static_cast>(_STD __std_count_trivial(_First_ptr, _Last_ptr, _Val)); + return static_cast>(_STD _Count_trivial(_First_ptr, _Last_ptr, _Val)); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -674,7 +674,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InI if (!_STD _Is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>); - const size_t _Pos = _STD __std_mismatch<_Elem_size>( + const size_t _Pos = _STD _Mismatch<_Elem_size>( _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast(_ULast1 - _UFirst1)); _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos); @@ -738,7 +738,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch( if (!_STD _Is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>); - const size_t _Pos = _STD __std_mismatch<_Elem_size>( + const size_t _Pos = _STD _Mismatch<_Elem_size>( _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast(_Count)); _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos); @@ -2976,7 +2976,7 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); const auto _Last_ptr = _First_ptr + _Count; - const auto _Result = _STD __std_find_last_trivial(_First_ptr, _Last_ptr, _Value); + const auto _Result = _STD _Find_last_trivial(_First_ptr, _Last_ptr, _Value); if constexpr (is_pointer_v<_It>) { return {_Result, _Last_ptr}; } else { @@ -3387,7 +3387,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of( if constexpr (_Vector_alg_in_find_first_of_is_safe) { if (!_STD _Is_constant_evaluated() && _ULast1 - _UFirst1 >= _Threshold_find_first_of) { const auto _First1_ptr = _STD _To_address(_UFirst1); - const auto _Result = _STD __std_find_first_of_trivial( + const auto _Result = _STD _Find_first_of_trivial( _First1_ptr, _STD _To_address(_ULast1), _STD _To_address(_UFirst2), _STD _To_address(_ULast2)); if constexpr (is_pointer_v) { @@ -3491,7 +3491,7 @@ namespace ranges { const auto _Last2_ptr = _First2_ptr + _Count2; const auto _Result = - _STD __std_find_first_of_trivial(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr); + _STD _Find_first_of_trivial(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr); if constexpr (is_pointer_v<_It1>) { return _Result; @@ -10049,7 +10049,7 @@ constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _ if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD __std_minmax_element(_First_ptr, _STD _To_address(_Last)); + const auto _Result = _STD _Minmax_element(_First_ptr, _STD _To_address(_Last)); if constexpr (is_pointer_v<_FwdIt>) { return _Result; } else { @@ -10176,7 +10176,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD __std_minmax_element(_First_ptr, _Last_ptr); + const auto _Result = _STD _Minmax_element(_First_ptr, _Last_ptr); if constexpr (is_pointer_v<_It>) { return {_Result.first, _Result.second}; } else { @@ -10254,7 +10254,7 @@ _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pr #if _USE_STD_VECTOR_ALGORITHMS if constexpr (_Is_min_max_optimization_safe) { if (!_STD _Is_constant_evaluated()) { - const auto _Result = _STD __std_minmax(_Ilist.begin(), _Ilist.end()); + const auto _Result = _STD _Minmax(_Ilist.begin(), _Ilist.end()); return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)}; } } @@ -10386,7 +10386,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD __std_minmax(_First_ptr, _Last_ptr); + const auto _Result = _STD _Minmax(_First_ptr, _Last_ptr); return {static_cast<_Vty>(_Result._Min), static_cast<_Vty>(_Result._Max)}; } } diff --git a/stl/inc/xutility b/stl/inc/xutility index f2e0482894..1a3e686779 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -133,9 +133,9 @@ __declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const _STD_BEGIN template -__declspec(noalias) size_t __std_count_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { +__declspec(noalias) size_t _Count_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { - return _STD __std_count_trivial(_First, _Last, reinterpret_cast(_Val)); + return _STD _Count_trivial(_First, _Last, reinterpret_cast(_Val)); } else if constexpr (sizeof(_Ty) == 1) { return ::__std_count_trivial_1(_First, _Last, static_cast(_Val)); } else if constexpr (sizeof(_Ty) == 2) { @@ -150,9 +150,9 @@ __declspec(noalias) size_t __std_count_trivial(_Ty* const _First, _Ty* const _La } template -_Ty* __std_find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { +_Ty* _Find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { - return _STD __std_find_trivial(_First, _Last, reinterpret_cast(_Val)); + return _STD _Find_trivial(_First, _Last, reinterpret_cast(_Val)); } else if constexpr (sizeof(_Ty) == 1) { return const_cast<_Ty*>( static_cast(::__std_find_trivial_1(_First, _Last, static_cast(_Val)))); @@ -171,7 +171,7 @@ _Ty* __std_find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) n } template -_Ty* __std_min_element(_Ty* const _First, _Ty* const _Last) noexcept { +_Ty* _Min_element(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_same_v, float>) { @@ -192,7 +192,7 @@ _Ty* __std_min_element(_Ty* const _First, _Ty* const _Last) noexcept { } template -_Ty* __std_max_element(_Ty* const _First, _Ty* const _Last) noexcept { +_Ty* _Max_element(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_same_v, float>) { @@ -213,7 +213,7 @@ _Ty* __std_max_element(_Ty* const _First, _Ty* const _Last) noexcept { } template -auto __std_min(_Ty* const _First, _Ty* const _Last) noexcept { +auto _Min(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_pointer_v<_Ty>) { @@ -256,7 +256,7 @@ auto __std_min(_Ty* const _First, _Ty* const _Last) noexcept { } template -auto __std_max(_Ty* const _First, _Ty* const _Last) noexcept { +auto _Max(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_pointer_v<_Ty>) { @@ -300,7 +300,7 @@ auto __std_max(_Ty* const _First, _Ty* const _Last) noexcept { template inline size_t // TRANSITION, GH-4496 - __std_mismatch(const void* const _First1, const void* const _First2, const size_t _Count) noexcept { + _Mismatch(const void* const _First1, const void* const _First2, const size_t _Count) noexcept { if constexpr (_Element_size == 1) { return __std_mismatch_1(_First1, _First2, _Count); } else if constexpr (_Element_size == 2) { @@ -5504,7 +5504,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(iter_value_t<_It1>); - const size_t _Pos = _STD __std_mismatch<_Elem_size>( + const size_t _Pos = _STD _Mismatch<_Elem_size>( _STD _To_address(_First1), _STD _To_address(_First2), static_cast(_Count)); return {_First1 + static_cast>(_Pos), @@ -5924,7 +5924,7 @@ _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, c } #if _USE_STD_VECTOR_ALGORITHMS const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD __std_find_trivial(_First_ptr, _STD _To_address(_Last), _Val); + const auto _Result = _STD _Find_trivial(_First_ptr, _STD _To_address(_Last), _Val); if constexpr (is_pointer_v<_InIt>) { return _Result; } else { @@ -6011,7 +6011,7 @@ namespace ranges { if constexpr (_Is_sized) { // When _Is_sized && _Single_byte_elements, prefer this over memchr() for performance const auto _Last_ptr = _First_ptr + (_Last - _First); - _Result = _STD __std_find_trivial(_First_ptr, _Last_ptr, _Val); + _Result = _STD _Find_trivial(_First_ptr, _Last_ptr, _Val); } else #endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^ { @@ -6101,7 +6101,7 @@ _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InI } return static_cast<_Iter_diff_t<_InIt>>( - _STD __std_count_trivial(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val)); + _STD _Count_trivial(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val)); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -6761,7 +6761,7 @@ constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD __std_max_element(_First_ptr, _STD _To_address(_Last)); + const auto _Result = _STD _Max_element(_First_ptr, _STD _To_address(_Last)); if constexpr (is_pointer_v<_FwdIt>) { return _Result; } else { @@ -6827,7 +6827,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD __std_max_element(_First_ptr, _Last_ptr); + const auto _Result = _STD _Max_element(_First_ptr, _Last_ptr); if constexpr (is_pointer_v<_It>) { return _Result; } else { @@ -6887,7 +6887,7 @@ _NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (_Is_min_max_optimization_safe) { if (!_Is_constant_evaluated()) { - return static_cast<_Ty>(_STD __std_max(_Ilist.begin(), _Ilist.end())); + return static_cast<_Ty>(_STD _Max(_Ilist.begin(), _Ilist.end())); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -6933,7 +6933,7 @@ namespace ranges { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe) { if (!_STD is_constant_evaluated()) { - return static_cast<_Ty>(_STD __std_max(_First, _Last)); + return static_cast<_Ty>(_STD _Max(_First, _Last)); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -6955,7 +6955,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_UFirst); const auto _Last_ptr = _First_ptr + (_ULast - _UFirst); - return static_cast>(_STD __std_max(_First_ptr, _Last_ptr)); + return static_cast>(_STD _Max(_First_ptr, _Last_ptr)); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -6985,7 +6985,7 @@ constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD __std_min_element(_First_ptr, _STD _To_address(_Last)); + const auto _Result = _STD _Min_element(_First_ptr, _STD _To_address(_Last)); if constexpr (is_pointer_v<_FwdIt>) { return _Result; } else { @@ -7051,7 +7051,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD __std_min_element(_First_ptr, _Last_ptr); + const auto _Result = _STD _Min_element(_First_ptr, _Last_ptr); if constexpr (is_pointer_v<_It>) { return _Result; } else { @@ -7111,7 +7111,7 @@ _NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (_Is_min_max_optimization_safe) { if (!_Is_constant_evaluated()) { - return static_cast<_Ty>(_STD __std_min(_Ilist.begin(), _Ilist.end())); + return static_cast<_Ty>(_STD _Min(_Ilist.begin(), _Ilist.end())); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -7151,7 +7151,7 @@ namespace ranges { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe) { if (!_STD is_constant_evaluated()) { - return static_cast<_Ty>(_STD __std_min(_First, _Last)); + return static_cast<_Ty>(_STD _Min(_First, _Last)); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -7173,7 +7173,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_UFirst); const auto _Last_ptr = _First_ptr + (_ULast - _UFirst); - return static_cast>(_STD __std_min(_First_ptr, _Last_ptr)); + return static_cast>(_STD _Min(_First_ptr, _Last_ptr)); } } #endif // _USE_STD_VECTOR_ALGORITHMS diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp index 1c5fc74e80..2ef1dd7fd4 100644 --- a/stl/src/vector_algorithms.cpp +++ b/stl/src/vector_algorithms.cpp @@ -1168,7 +1168,7 @@ namespace { // This makes sure the template specialization is fused with the extern "C" function. // In optimized builds it avoids an extra call, as this function is too large to inline. template <_Min_max_mode _Mode, class _Traits> - auto __stdcall _Minmax_element(const void* _First, const void* const _Last, const bool _Sign) noexcept { + auto __stdcall __std_minmax_element_impl(const void* _First, const void* const _Last, const bool _Sign) noexcept { _Min_max_element_t _Res = {_First, _First}; auto _Cur_min_val = _Traits::_Init_min_val; auto _Cur_max_val = _Traits::_Init_max_val; @@ -1391,7 +1391,7 @@ namespace { // This makes sure the template specialization is fused with the extern "C" function. // In optimized builds it avoids an extra call, as this function is too large to inline. template <_Min_max_mode _Mode, class _Traits, bool _Sign> - auto __stdcall _Minmax(const void* _First, const void* const _Last) noexcept { + auto __stdcall __std_minmax_impl(const void* _First, const void* const _Last) noexcept { using _Ty = std::conditional_t<_Sign, typename _Traits::_Signed_t, typename _Traits::_Unsigned_t>; _Ty _Cur_min_val; // initialized in both of the branches below @@ -1529,212 +1529,212 @@ extern "C" { const void* __stdcall __std_min_element_1( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_min, _Minmax_traits_1>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_min, _Minmax_traits_1>(_First, _Last, _Signed); } const void* __stdcall __std_min_element_2( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_min, _Minmax_traits_2>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_min, _Minmax_traits_2>(_First, _Last, _Signed); } const void* __stdcall __std_min_element_4( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_min, _Minmax_traits_4>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_min, _Minmax_traits_4>(_First, _Last, _Signed); } const void* __stdcall __std_min_element_8( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_min, _Minmax_traits_8>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_min, _Minmax_traits_8>(_First, _Last, _Signed); } const void* __stdcall __std_min_element_f( // _Minmax_element's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { - return _Minmax_element<_Mode_min, _Minmax_traits_f>(_First, _Last, _Unused); + return __std_minmax_element_impl<_Mode_min, _Minmax_traits_f>(_First, _Last, _Unused); } const void* __stdcall __std_min_element_d( // _Minmax_element's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { - return _Minmax_element<_Mode_min, _Minmax_traits_d>(_First, _Last, _Unused); + return __std_minmax_element_impl<_Mode_min, _Minmax_traits_d>(_First, _Last, _Unused); } const void* __stdcall __std_max_element_1( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_max, _Minmax_traits_1>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_max, _Minmax_traits_1>(_First, _Last, _Signed); } const void* __stdcall __std_max_element_2( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_max, _Minmax_traits_2>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_max, _Minmax_traits_2>(_First, _Last, _Signed); } const void* __stdcall __std_max_element_4( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_max, _Minmax_traits_4>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_max, _Minmax_traits_4>(_First, _Last, _Signed); } const void* __stdcall __std_max_element_8( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_max, _Minmax_traits_8>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_max, _Minmax_traits_8>(_First, _Last, _Signed); } const void* __stdcall __std_max_element_f( // _Minmax_element's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { - return _Minmax_element<_Mode_max, _Minmax_traits_f>(_First, _Last, _Unused); + return __std_minmax_element_impl<_Mode_max, _Minmax_traits_f>(_First, _Last, _Unused); } const void* __stdcall __std_max_element_d( // _Minmax_element's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { - return _Minmax_element<_Mode_max, _Minmax_traits_d>(_First, _Last, _Unused); + return __std_minmax_element_impl<_Mode_max, _Minmax_traits_d>(_First, _Last, _Unused); } _Min_max_element_t __stdcall __std_minmax_element_1( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_both, _Minmax_traits_1>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_both, _Minmax_traits_1>(_First, _Last, _Signed); } _Min_max_element_t __stdcall __std_minmax_element_2( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_both, _Minmax_traits_2>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_both, _Minmax_traits_2>(_First, _Last, _Signed); } _Min_max_element_t __stdcall __std_minmax_element_4( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_both, _Minmax_traits_4>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_both, _Minmax_traits_4>(_First, _Last, _Signed); } _Min_max_element_t __stdcall __std_minmax_element_8( const void* const _First, const void* const _Last, const bool _Signed) noexcept { - return _Minmax_element<_Mode_both, _Minmax_traits_8>(_First, _Last, _Signed); + return __std_minmax_element_impl<_Mode_both, _Minmax_traits_8>(_First, _Last, _Signed); } _Min_max_element_t __stdcall __std_minmax_element_f( // _Minmax_element's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { - return _Minmax_element<_Mode_both, _Minmax_traits_f>(_First, _Last, _Unused); + return __std_minmax_element_impl<_Mode_both, _Minmax_traits_f>(_First, _Last, _Unused); } _Min_max_element_t __stdcall __std_minmax_element_d( // _Minmax_element's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { - return _Minmax_element<_Mode_both, _Minmax_traits_d>(_First, _Last, _Unused); + return __std_minmax_element_impl<_Mode_both, _Minmax_traits_d>(_First, _Last, _Unused); } __declspec(noalias) int8_t __stdcall __std_min_1i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_1, true>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_1, true>(_First, _Last); } __declspec(noalias) uint8_t __stdcall __std_min_1u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_1, false>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_1, false>(_First, _Last); } __declspec(noalias) int16_t __stdcall __std_min_2i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_2, true>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_2, true>(_First, _Last); } __declspec(noalias) uint16_t __stdcall __std_min_2u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_2, false>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_2, false>(_First, _Last); } __declspec(noalias) int32_t __stdcall __std_min_4i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_4, true>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_4, true>(_First, _Last); } __declspec(noalias) uint32_t __stdcall __std_min_4u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_4, false>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_4, false>(_First, _Last); } __declspec(noalias) int64_t __stdcall __std_min_8i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_8, true>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_8, true>(_First, _Last); } __declspec(noalias) uint64_t __stdcall __std_min_8u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_8, false>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_8, false>(_First, _Last); } __declspec(noalias) float __stdcall __std_min_f(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_f, true>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_f, true>(_First, _Last); } __declspec(noalias) double __stdcall __std_min_d(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_min, _Minmax_traits_d, true>(_First, _Last); + return __std_minmax_impl<_Mode_min, _Minmax_traits_d, true>(_First, _Last); } __declspec(noalias) int8_t __stdcall __std_max_1i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_1, true>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_1, true>(_First, _Last); } __declspec(noalias) uint8_t __stdcall __std_max_1u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_1, false>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_1, false>(_First, _Last); } __declspec(noalias) int16_t __stdcall __std_max_2i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_2, true>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_2, true>(_First, _Last); } __declspec(noalias) uint16_t __stdcall __std_max_2u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_2, false>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_2, false>(_First, _Last); } __declspec(noalias) int32_t __stdcall __std_max_4i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_4, true>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_4, true>(_First, _Last); } __declspec(noalias) uint32_t __stdcall __std_max_4u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_4, false>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_4, false>(_First, _Last); } __declspec(noalias) int64_t __stdcall __std_max_8i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_8, true>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_8, true>(_First, _Last); } __declspec(noalias) uint64_t __stdcall __std_max_8u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_8, false>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_8, false>(_First, _Last); } __declspec(noalias) float __stdcall __std_max_f(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_f, true>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_f, true>(_First, _Last); } __declspec(noalias) double __stdcall __std_max_d(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_max, _Minmax_traits_d, true>(_First, _Last); + return __std_minmax_impl<_Mode_max, _Minmax_traits_d, true>(_First, _Last); } __declspec(noalias) _Min_max_1i __stdcall __std_minmax_1i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_1, true>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_1, true>(_First, _Last); } __declspec(noalias) _Min_max_1u __stdcall __std_minmax_1u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_1, false>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_1, false>(_First, _Last); } __declspec(noalias) _Min_max_2i __stdcall __std_minmax_2i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_2, true>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_2, true>(_First, _Last); } __declspec(noalias) _Min_max_2u __stdcall __std_minmax_2u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_2, false>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_2, false>(_First, _Last); } __declspec(noalias) _Min_max_4i __stdcall __std_minmax_4i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_4, true>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_4, true>(_First, _Last); } __declspec(noalias) _Min_max_4u __stdcall __std_minmax_4u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_4, false>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_4, false>(_First, _Last); } __declspec(noalias) _Min_max_8i __stdcall __std_minmax_8i(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_8, true>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_8, true>(_First, _Last); } __declspec(noalias) _Min_max_8u __stdcall __std_minmax_8u(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_8, false>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_8, false>(_First, _Last); } __declspec(noalias) _Min_max_f __stdcall __std_minmax_f(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_f, true>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_f, true>(_First, _Last); } __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* const _First, const void* const _Last) noexcept { - return _Minmax<_Mode_both, _Minmax_traits_d, true>(_First, _Last); + return __std_minmax_impl<_Mode_both, _Minmax_traits_d, true>(_First, _Last); } } // extern "C" From e4e5dc7cf35aed3f67a750e953ef168f893722ee Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 08:36:51 +0300 Subject: [PATCH 02/27] Avoid recursion in dispatchers So that some of them can be inlined due to just one call site --- stl/inc/algorithm | 8 +++++++- stl/inc/xutility | 14 ++++++++++++-- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 8a2ab3c249..ef2db8193c 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -148,7 +148,13 @@ auto _Minmax(_Ty* const _First, _Ty* const _Last) noexcept { template _Ty* _Find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { - return _STD _Find_last_trivial(_First, _Last, reinterpret_cast(_Val)); +#ifdef _WIN64 + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_8(_First, _Last, reinterpret_cast(_Val)))); +#else + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_4(_First, _Last, reinterpret_cast(_Val)))); +#endif } else if constexpr (sizeof(_Ty) == 1) { return const_cast<_Ty*>( static_cast(::__std_find_last_trivial_1(_First, _Last, static_cast(_Val)))); diff --git a/stl/inc/xutility b/stl/inc/xutility index 1a3e686779..1125339c2e 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -135,7 +135,11 @@ _STD_BEGIN template __declspec(noalias) size_t _Count_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { - return _STD _Count_trivial(_First, _Last, reinterpret_cast(_Val)); +#ifdef _WIN64 + return ::__std_count_trivial_8(_First, _Last, reinterpret_cast(_Val)); +#else + return ::__std_count_trivial_4(_First, _Last, reinterpret_cast(_Val)); +#endif } else if constexpr (sizeof(_Ty) == 1) { return ::__std_count_trivial_1(_First, _Last, static_cast(_Val)); } else if constexpr (sizeof(_Ty) == 2) { @@ -152,7 +156,13 @@ __declspec(noalias) size_t _Count_trivial(_Ty* const _First, _Ty* const _Last, c template _Ty* _Find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { - return _STD _Find_trivial(_First, _Last, reinterpret_cast(_Val)); +#ifdef _WIN64 + return const_cast<_Ty*>( + static_cast(::__std_find_trivial_8(_First, _Last, reinterpret_cast(_Val)))); +#else + return const_cast<_Ty*>( + static_cast(::__std_find_trivial_4(_First, _Last, reinterpret_cast(_Val)))); +#endif } else if constexpr (sizeof(_Ty) == 1) { return const_cast<_Ty*>( static_cast(::__std_find_trivial_1(_First, _Last, static_cast(_Val)))); From 68c7ec2543ab969a0b5bb39d712aeba2482ba953 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 08:58:15 +0300 Subject: [PATCH 03/27] inline `_Find_last_trivial` --- stl/inc/algorithm | 52 ++++++++++++++++++++++------------------------- 1 file changed, 24 insertions(+), 28 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index ef2db8193c..bb67f43796 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -145,33 +145,6 @@ auto _Minmax(_Ty* const _First, _Ty* const _Last) noexcept { } } -template -_Ty* _Find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { - if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { -#ifdef _WIN64 - return const_cast<_Ty*>( - static_cast(::__std_find_last_trivial_8(_First, _Last, reinterpret_cast(_Val)))); -#else - return const_cast<_Ty*>( - static_cast(::__std_find_last_trivial_4(_First, _Last, reinterpret_cast(_Val)))); -#endif - } else if constexpr (sizeof(_Ty) == 1) { - return const_cast<_Ty*>( - static_cast(::__std_find_last_trivial_1(_First, _Last, static_cast(_Val)))); - } else if constexpr (sizeof(_Ty) == 2) { - return const_cast<_Ty*>( - static_cast(::__std_find_last_trivial_2(_First, _Last, static_cast(_Val)))); - } else if constexpr (sizeof(_Ty) == 4) { - return const_cast<_Ty*>( - static_cast(::__std_find_last_trivial_4(_First, _Last, static_cast(_Val)))); - } else if constexpr (sizeof(_Ty) == 8) { - return const_cast<_Ty*>( - static_cast(::__std_find_last_trivial_8(_First, _Last, static_cast(_Val)))); - } else { - static_assert(_Always_false<_Ty>, "Unexpected size"); - } -} - template _Ty1* _Find_first_of_trivial( _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept { @@ -2982,7 +2955,30 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); const auto _Last_ptr = _First_ptr + _Count; - const auto _Result = _STD _Find_last_trivial(_First_ptr, _Last_ptr, _Value); + if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { +#ifdef _WIN64 + _Result = const_cast<_Ty*>(static_cast( + ::__std_find_last_trivial_8(_First_ptr, _Last_ptr, reinterpret_cast(_Value)))); +#else + _Result = const_cast<_Ty*>(static_cast( + ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, reinterpret_cast(_Value)))); +#endif + } else if constexpr (sizeof(_Ty) == 1) { + _Result = const_cast<_Ty*>(static_cast( + ::__std_find_last_trivial_1(_First_ptr, _Last_ptr, static_cast(_Value)))); + } else if constexpr (sizeof(_Ty) == 2) { + _Result = const_cast<_Ty*>(static_cast( + ::__std_find_last_trivial_2(_First_ptr, _Last_ptr, static_cast(_Value)))); + } else if constexpr (sizeof(_Ty) == 4) { + _Result = const_cast<_Ty*>(static_cast( + ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, static_cast(_Value)))); + } else if constexpr (sizeof(_Ty) == 8) { + _Result = const_cast<_Ty*>(static_cast( + ::__std_find_last_trivial_8(_First_ptr, _Last_ptr, static_cast(_Value)))); + } else { + static_assert(_Always_false<_Ty>, "Unexpected size"); + } + if constexpr (is_pointer_v<_It>) { return {_Result, _Last_ptr}; } else { From 5cc03a58e31ba3c57af87bd52db5eaf65dcff486 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 09:15:14 +0300 Subject: [PATCH 04/27] extract reverse copies --- stl/inc/algorithm | 58 ++++++++++++++++------------------------------- stl/inc/xutility | 24 ++++++++++++-------- 2 files changed, 33 insertions(+), 49 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index bb67f43796..4364944a1e 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -76,6 +76,20 @@ __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, cons } // extern "C" _STD_BEGIN +template +__declspec(noalias) void _Reverse_copy_trivially_copyable( + const void* _First, const void* _Last, void* _Dest) { + if constexpr (_Nx == 1) { + ::__std_reverse_copy_trivially_copyable_1(_First, _Last, _Dest); + } else if constexpr (_Nx == 2) { + ::__std_reverse_copy_trivially_copyable_2(_First, _Last, _Dest); + } else if constexpr (_Nx == 4) { + ::__std_reverse_copy_trivially_copyable_4(_First, _Last, _Dest); + } else { + ::__std_reverse_copy_trivially_copyable_8(_First, _Last, _Dest); + } +} + template pair<_Ty*, _Ty*> _Minmax_element(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; @@ -4921,18 +4935,7 @@ namespace ranges { if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) { if (!_STD is_constant_evaluated()) { - _Elem* const _First_addr = _STD to_address(_First); - _Elem* const _Last_addr = _STD to_address(_Last); - if constexpr (_Nx == 1) { - ::__std_reverse_trivially_swappable_1(_First_addr, _Last_addr); - } else if constexpr (_Nx == 2) { - ::__std_reverse_trivially_swappable_2(_First_addr, _Last_addr); - } else if constexpr (_Nx == 4) { - ::__std_reverse_trivially_swappable_4(_First_addr, _Last_addr); - } else { - ::__std_reverse_trivially_swappable_8(_First_addr, _Last_addr); - } - + _STD _Reverse_trivially_swappable<_Nx>(_STD _To_address(_First), _STD _To_address(_Last)); return; } } @@ -4991,20 +4994,8 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) { if (!_STD is_constant_evaluated()) #endif // _HAS_CXX20 { - if constexpr (_Nx == 1) { - ::__std_reverse_copy_trivially_copyable_1( - _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest)); - } else if constexpr (_Nx == 2) { - ::__std_reverse_copy_trivially_copyable_2( - _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest)); - } else if constexpr (_Nx == 4) { - ::__std_reverse_copy_trivially_copyable_4( - _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest)); - } else { - ::__std_reverse_copy_trivially_copyable_8( - _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest)); - } - + _Reverse_copy_trivially_copyable( + _STD to_address(_UFirst), _STD to_address(_ULast), _STD to_address(_UDest)); _UDest += _ULast - _UFirst; _STD _Seek_wrapped(_Dest, _UDest); return _Dest; @@ -5080,19 +5071,8 @@ namespace ranges { if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) { if (!_STD is_constant_evaluated()) { - _Elem* const _First_addr = _STD to_address(_First); - _Elem* const _Last_addr = _STD to_address(_Last); - _DestElem* const _Result_addr = _STD to_address(_Result); - if constexpr (_Nx == 1) { - ::__std_reverse_copy_trivially_copyable_1(_First_addr, _Last_addr, _Result_addr); - } else if constexpr (_Nx == 2) { - ::__std_reverse_copy_trivially_copyable_2(_First_addr, _Last_addr, _Result_addr); - } else if constexpr (_Nx == 4) { - ::__std_reverse_copy_trivially_copyable_4(_First_addr, _Last_addr, _Result_addr); - } else { - ::__std_reverse_copy_trivially_copyable_8(_First_addr, _Last_addr, _Result_addr); - } - + _Reverse_copy_trivially_copyable( + _STD to_address(_First), _STD to_address(_Last), _STD to_address(_Result)); _Result += _Last - _First; return _Result; } diff --git a/stl/inc/xutility b/stl/inc/xutility index 1125339c2e..dadd02672a 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -132,6 +132,19 @@ __declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const } // extern "C" _STD_BEGIN +template +__declspec(noalias) void _Reverse_trivially_swappable(void* _First, void* _Last) noexcept { + if constexpr (_Nx == 1) { + ::__std_reverse_trivially_swappable_1(_First, _Last); + } else if constexpr (_Nx == 2) { + ::__std_reverse_trivially_swappable_2(_First, _Last); + } else if constexpr (_Nx == 4) { + ::__std_reverse_trivially_swappable_4(_First, _Last); + } else { + ::__std_reverse_trivially_swappable_8(_First, _Last); + } +} + template __declspec(noalias) size_t _Count_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { @@ -6315,16 +6328,7 @@ _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse if (!_STD is_constant_evaluated()) #endif // _HAS_CXX20 { - if constexpr (_Nx == 1) { - ::__std_reverse_trivially_swappable_1(_STD _To_address(_UFirst), _STD _To_address(_ULast)); - } else if constexpr (_Nx == 2) { - ::__std_reverse_trivially_swappable_2(_STD _To_address(_UFirst), _STD _To_address(_ULast)); - } else if constexpr (_Nx == 4) { - ::__std_reverse_trivially_swappable_4(_STD _To_address(_UFirst), _STD _To_address(_ULast)); - } else { - ::__std_reverse_trivially_swappable_8(_STD _To_address(_UFirst), _STD _To_address(_ULast)); - } - + _STD _Reverse_trivially_swappable<_Nx>(_STD _To_address(_UFirst), _STD _To_address(_ULast)); return; } } From 17f0a2639b827fa7b1d708897da866bce3833f15 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 09:20:32 +0300 Subject: [PATCH 05/27] missing `_STD` --- stl/inc/algorithm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 4364944a1e..8e003cbc08 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -4994,7 +4994,7 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) { if (!_STD is_constant_evaluated()) #endif // _HAS_CXX20 { - _Reverse_copy_trivially_copyable( + _STD _Reverse_copy_trivially_copyable( _STD to_address(_UFirst), _STD to_address(_ULast), _STD to_address(_UDest)); _UDest += _ULast - _UFirst; _STD _Seek_wrapped(_Dest, _UDest); @@ -5071,7 +5071,7 @@ namespace ranges { if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) { if (!_STD is_constant_evaluated()) { - _Reverse_copy_trivially_copyable( + _STD _Reverse_copy_trivially_copyable( _STD to_address(_First), _STD to_address(_Last), _STD to_address(_Result)); _Result += _Last - _First; return _Result; From 0fe3958bfccdab3814bc2e93aedb4ee6dd7a5b30 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 09:27:54 +0300 Subject: [PATCH 06/27] clang format --- stl/inc/algorithm | 8 +++----- stl/inc/xutility | 2 +- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 8e003cbc08..c54e4f13f6 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -76,9 +76,8 @@ __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, cons } // extern "C" _STD_BEGIN -template -__declspec(noalias) void _Reverse_copy_trivially_copyable( - const void* _First, const void* _Last, void* _Dest) { +template +__declspec(noalias) void _Reverse_copy_trivially_copyable(const void* _First, const void* _Last, void* _Dest) { if constexpr (_Nx == 1) { ::__std_reverse_copy_trivially_copyable_1(_First, _Last, _Dest); } else if constexpr (_Nx == 2) { @@ -3506,8 +3505,7 @@ namespace ranges { const auto _First2_ptr = _STD _To_address(_First2); const auto _Last2_ptr = _First2_ptr + _Count2; - const auto _Result = - _STD _Find_first_of_trivial(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr); + const auto _Result = _STD _Find_first_of_trivial(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr); if constexpr (is_pointer_v<_It1>) { return _Result; diff --git a/stl/inc/xutility b/stl/inc/xutility index dadd02672a..8a1b4e8ce3 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -132,7 +132,7 @@ __declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const } // extern "C" _STD_BEGIN -template +template __declspec(noalias) void _Reverse_trivially_swappable(void* _First, void* _Last) noexcept { if constexpr (_Nx == 1) { ::__std_reverse_trivially_swappable_1(_First, _Last); From 626fc8e51a66f8355f4747535ef5b0cc36b1a004 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 09:37:57 +0300 Subject: [PATCH 07/27] missing variable --- stl/inc/algorithm | 2 ++ 1 file changed, 2 insertions(+) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index c54e4f13f6..9d255808c2 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -2968,6 +2968,8 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); const auto _Last_ptr = _First_ptr + _Count; + _Ty* _Result; + if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { #ifdef _WIN64 _Result = const_cast<_Ty*>(static_cast( From 30eb5a0ce0e2ae8461ef3b18faabe6e5ad0575f7 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 09:55:41 +0300 Subject: [PATCH 08/27] types --- stl/inc/algorithm | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 9d255808c2..4ea670405b 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -2968,27 +2968,28 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); const auto _Last_ptr = _First_ptr + _Count; - _Ty* _Result; + using _TVal = iter_value_t<_It>; + _TVal* _Result; - if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { + if constexpr (is_pointer_v<_Ty> || is_null_pointer_v<_Ty>) { #ifdef _WIN64 - _Result = const_cast<_Ty*>(static_cast( + _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_8(_First_ptr, _Last_ptr, reinterpret_cast(_Value)))); #else - _Result = const_cast<_Ty*>(static_cast( + _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, reinterpret_cast(_Value)))); #endif } else if constexpr (sizeof(_Ty) == 1) { - _Result = const_cast<_Ty*>(static_cast( + _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_1(_First_ptr, _Last_ptr, static_cast(_Value)))); } else if constexpr (sizeof(_Ty) == 2) { - _Result = const_cast<_Ty*>(static_cast( + _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_2(_First_ptr, _Last_ptr, static_cast(_Value)))); } else if constexpr (sizeof(_Ty) == 4) { - _Result = const_cast<_Ty*>(static_cast( + _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, static_cast(_Value)))); } else if constexpr (sizeof(_Ty) == 8) { - _Result = const_cast<_Ty*>(static_cast( + _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_8(_First_ptr, _Last_ptr, static_cast(_Value)))); } else { static_assert(_Always_false<_Ty>, "Unexpected size"); From e2532d42abe65d2b223282811deb18aa7ed8fba2 Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 09:59:25 +0300 Subject: [PATCH 09/27] types this way look safer --- stl/inc/algorithm | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 4ea670405b..298b3d74f1 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -2979,16 +2979,16 @@ namespace ranges { _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, reinterpret_cast(_Value)))); #endif - } else if constexpr (sizeof(_Ty) == 1) { + } else if constexpr (sizeof(_TVal) == 1) { _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_1(_First_ptr, _Last_ptr, static_cast(_Value)))); - } else if constexpr (sizeof(_Ty) == 2) { + } else if constexpr (sizeof(_TVal) == 2) { _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_2(_First_ptr, _Last_ptr, static_cast(_Value)))); - } else if constexpr (sizeof(_Ty) == 4) { + } else if constexpr (sizeof(_TVal) == 4) { _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, static_cast(_Value)))); - } else if constexpr (sizeof(_Ty) == 8) { + } else if constexpr (sizeof(_TVal) == 8) { _Result = const_cast<_TVal*>(static_cast( ::__std_find_last_trivial_8(_First_ptr, _Last_ptr, static_cast(_Value)))); } else { From 1203114c6b124f8995cca3aa2881114368d83c3a Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 10:26:28 +0300 Subject: [PATCH 10/27] template param --- stl/inc/algorithm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 298b3d74f1..6a1a33bf3e 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -4995,7 +4995,7 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) { if (!_STD is_constant_evaluated()) #endif // _HAS_CXX20 { - _STD _Reverse_copy_trivially_copyable( + _STD _Reverse_copy_trivially_copyable<_Nx>( _STD to_address(_UFirst), _STD to_address(_ULast), _STD to_address(_UDest)); _UDest += _ULast - _UFirst; _STD _Seek_wrapped(_Dest, _UDest); @@ -5072,7 +5072,7 @@ namespace ranges { if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) { if (!_STD is_constant_evaluated()) { - _STD _Reverse_copy_trivially_copyable( + _STD _Reverse_copy_trivially_copyable<_Nx>( _STD to_address(_First), _STD to_address(_Last), _STD to_address(_Result)); _Result += _Last - _First; return _Result; From c5f8d229923392792cae7e40e53fa867d2694fbb Mon Sep 17 00:00:00 2001 From: Alex Guteniev Date: Sun, 31 Mar 2024 11:00:51 +0300 Subject: [PATCH 11/27] correct to_address use --- stl/inc/algorithm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 6a1a33bf3e..a21eeec8db 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -4936,7 +4936,7 @@ namespace ranges { if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) { if (!_STD is_constant_evaluated()) { - _STD _Reverse_trivially_swappable<_Nx>(_STD _To_address(_First), _STD _To_address(_Last)); + _STD _Reverse_trivially_swappable<_Nx>(_STD to_address(_First), _STD to_address(_Last)); return; } } @@ -4996,7 +4996,7 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) { #endif // _HAS_CXX20 { _STD _Reverse_copy_trivially_copyable<_Nx>( - _STD to_address(_UFirst), _STD to_address(_ULast), _STD to_address(_UDest)); + _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest)); _UDest += _ULast - _UFirst; _STD _Seek_wrapped(_Dest, _UDest); return _Dest; From 3f8857e6944c38ae8a8cd91a13916830cde686f9 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:07:24 -0700 Subject: [PATCH 12/27] Verify `_Nx == 8`. --- stl/inc/algorithm | 4 +++- stl/inc/xutility | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index a21eeec8db..0211db5276 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -84,8 +84,10 @@ __declspec(noalias) void _Reverse_copy_trivially_copyable(const void* _First, co ::__std_reverse_copy_trivially_copyable_2(_First, _Last, _Dest); } else if constexpr (_Nx == 4) { ::__std_reverse_copy_trivially_copyable_4(_First, _Last, _Dest); - } else { + } else if constexpr (_Nx == 8) { ::__std_reverse_copy_trivially_copyable_8(_First, _Last, _Dest); + } else { + static_assert(_Always_false>, "Unexpected size"); } } diff --git a/stl/inc/xutility b/stl/inc/xutility index 8a1b4e8ce3..bec2aa930f 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -140,8 +140,10 @@ __declspec(noalias) void _Reverse_trivially_swappable(void* _First, void* _Last) ::__std_reverse_trivially_swappable_2(_First, _Last); } else if constexpr (_Nx == 4) { ::__std_reverse_trivially_swappable_4(_First, _Last); - } else { + } else if constexpr (_Nx == 8) { ::__std_reverse_trivially_swappable_8(_First, _Last); + } else { + static_assert(_Always_false>, "Unexpected size"); } } From 969399757bb9f61fab13d4c4b15ad12b4f11ff4d Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:16:04 -0700 Subject: [PATCH 13/27] Update comments for renamed functions. --- stl/src/vector_algorithms.cpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp index 2ef1dd7fd4..321dd09ebe 100644 --- a/stl/src/vector_algorithms.cpp +++ b/stl/src/vector_algorithms.cpp @@ -1163,7 +1163,7 @@ namespace { #endif // !_M_ARM64EC }; - // _Minmax_element has exactly the same signature as the extern "C" functions + // __std_minmax_element_impl has exactly the same signature as the extern "C" functions // (__std_min_element_N, __std_max_element_N, __std_minmax_element_N), up to calling convention. // This makes sure the template specialization is fused with the extern "C" function. // In optimized builds it avoids an extra call, as this function is too large to inline. @@ -1386,7 +1386,7 @@ namespace { } } - // _Minmax has exactly the same signature as the extern "C" functions + // __std_minmax_impl has exactly the same signature as the extern "C" functions // (__std_min_Nn, __std_max_Nn, __std_minmax_Nn), up to calling convention. // This makes sure the template specialization is fused with the extern "C" function. // In optimized builds it avoids an extra call, as this function is too large to inline. @@ -1547,12 +1547,12 @@ const void* __stdcall __std_min_element_8( return __std_minmax_element_impl<_Mode_min, _Minmax_traits_8>(_First, _Last, _Signed); } -const void* __stdcall __std_min_element_f( // _Minmax_element's "signature" comment explains `bool _Unused` +const void* __stdcall __std_min_element_f( // __std_minmax_element_impl's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { return __std_minmax_element_impl<_Mode_min, _Minmax_traits_f>(_First, _Last, _Unused); } -const void* __stdcall __std_min_element_d( // _Minmax_element's "signature" comment explains `bool _Unused` +const void* __stdcall __std_min_element_d( // __std_minmax_element_impl's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { return __std_minmax_element_impl<_Mode_min, _Minmax_traits_d>(_First, _Last, _Unused); } @@ -1577,12 +1577,12 @@ const void* __stdcall __std_max_element_8( return __std_minmax_element_impl<_Mode_max, _Minmax_traits_8>(_First, _Last, _Signed); } -const void* __stdcall __std_max_element_f( // _Minmax_element's "signature" comment explains `bool _Unused` +const void* __stdcall __std_max_element_f( // __std_minmax_element_impl's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { return __std_minmax_element_impl<_Mode_max, _Minmax_traits_f>(_First, _Last, _Unused); } -const void* __stdcall __std_max_element_d( // _Minmax_element's "signature" comment explains `bool _Unused` +const void* __stdcall __std_max_element_d( // __std_minmax_element_impl's "signature" comment explains `bool _Unused` const void* const _First, const void* const _Last, const bool _Unused) noexcept { return __std_minmax_element_impl<_Mode_max, _Minmax_traits_d>(_First, _Last, _Unused); } @@ -1607,12 +1607,14 @@ _Min_max_element_t __stdcall __std_minmax_element_8( return __std_minmax_element_impl<_Mode_both, _Minmax_traits_8>(_First, _Last, _Signed); } -_Min_max_element_t __stdcall __std_minmax_element_f( // _Minmax_element's "signature" comment explains `bool _Unused` +// __std_minmax_element_impl's "signature" comment explains `bool _Unused` +_Min_max_element_t __stdcall __std_minmax_element_f( const void* const _First, const void* const _Last, const bool _Unused) noexcept { return __std_minmax_element_impl<_Mode_both, _Minmax_traits_f>(_First, _Last, _Unused); } -_Min_max_element_t __stdcall __std_minmax_element_d( // _Minmax_element's "signature" comment explains `bool _Unused` +// __std_minmax_element_impl's "signature" comment explains `bool _Unused` +_Min_max_element_t __stdcall __std_minmax_element_d( const void* const _First, const void* const _Last, const bool _Unused) noexcept { return __std_minmax_element_impl<_Mode_both, _Minmax_traits_d>(_First, _Last, _Unused); } From 2fe0e783d4b1b2bddeb7521a4bd358b84f087110 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:50:56 -0700 Subject: [PATCH 14/27] `_Count_trivial` => `_Count_vectorized` --- stl/inc/algorithm | 2 +- stl/inc/xutility | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 0211db5276..17200738d8 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -572,7 +572,7 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - return static_cast>(_STD _Count_trivial(_First_ptr, _Last_ptr, _Val)); + return static_cast>(_STD _Count_vectorized(_First_ptr, _Last_ptr, _Val)); } } #endif // _USE_STD_VECTOR_ALGORITHMS diff --git a/stl/inc/xutility b/stl/inc/xutility index bec2aa930f..1a53435918 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -148,7 +148,7 @@ __declspec(noalias) void _Reverse_trivially_swappable(void* _First, void* _Last) } template -__declspec(noalias) size_t _Count_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { +__declspec(noalias) size_t _Count_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { #ifdef _WIN64 return ::__std_count_trivial_8(_First, _Last, reinterpret_cast(_Val)); @@ -6126,7 +6126,7 @@ _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InI } return static_cast<_Iter_diff_t<_InIt>>( - _STD _Count_trivial(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val)); + _STD _Count_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val)); } } #endif // _USE_STD_VECTOR_ALGORITHMS From e1634e7a2255cb7b3688e129232939119ca43bc6 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:51:54 -0700 Subject: [PATCH 15/27] `_Find_trivial` => `_Find_vectorized` --- stl/inc/xutility | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/xutility b/stl/inc/xutility index 1a53435918..d27cbca6cd 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -169,7 +169,7 @@ __declspec(noalias) size_t _Count_vectorized(_Ty* const _First, _Ty* const _Last } template -_Ty* _Find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { +_Ty* _Find_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { #ifdef _WIN64 return const_cast<_Ty*>( @@ -5949,7 +5949,7 @@ _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, c } #if _USE_STD_VECTOR_ALGORITHMS const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD _Find_trivial(_First_ptr, _STD _To_address(_Last), _Val); + const auto _Result = _STD _Find_vectorized(_First_ptr, _STD _To_address(_Last), _Val); if constexpr (is_pointer_v<_InIt>) { return _Result; } else { @@ -6036,7 +6036,7 @@ namespace ranges { if constexpr (_Is_sized) { // When _Is_sized && _Single_byte_elements, prefer this over memchr() for performance const auto _Last_ptr = _First_ptr + (_Last - _First); - _Result = _STD _Find_trivial(_First_ptr, _Last_ptr, _Val); + _Result = _STD _Find_vectorized(_First_ptr, _Last_ptr, _Val); } else #endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^ { From 7e78deba99c3a99a9cc57ce867039dc53a43b06e Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:52:54 -0700 Subject: [PATCH 16/27] `_Find_first_of_trivial` => `_Find_first_of_vectorized` --- stl/inc/algorithm | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 17200738d8..21275494ea 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -161,7 +161,7 @@ auto _Minmax(_Ty* const _First, _Ty* const _Last) noexcept { } template -_Ty1* _Find_first_of_trivial( +_Ty1* _Find_first_of_vectorized( _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept { if constexpr (sizeof(_Ty1) == 1) { return const_cast<_Ty1*>( @@ -3407,7 +3407,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of( if constexpr (_Vector_alg_in_find_first_of_is_safe) { if (!_STD _Is_constant_evaluated() && _ULast1 - _UFirst1 >= _Threshold_find_first_of) { const auto _First1_ptr = _STD _To_address(_UFirst1); - const auto _Result = _STD _Find_first_of_trivial( + const auto _Result = _STD _Find_first_of_vectorized( _First1_ptr, _STD _To_address(_ULast1), _STD _To_address(_UFirst2), _STD _To_address(_ULast2)); if constexpr (is_pointer_v) { @@ -3510,7 +3510,8 @@ namespace ranges { const auto _First2_ptr = _STD _To_address(_First2); const auto _Last2_ptr = _First2_ptr + _Count2; - const auto _Result = _STD _Find_first_of_trivial(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr); + const auto _Result = + _STD _Find_first_of_vectorized(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr); if constexpr (is_pointer_v<_It1>) { return _Result; From e69d4914bd54efb0a57bf5873b16af69ffbdfda4 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:55:54 -0700 Subject: [PATCH 17/27] `_Reverse_copy_trivially_copyable` => `_Reverse_copy_vectorized` --- stl/inc/algorithm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 21275494ea..65b3009e80 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -77,7 +77,7 @@ __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, cons _STD_BEGIN template -__declspec(noalias) void _Reverse_copy_trivially_copyable(const void* _First, const void* _Last, void* _Dest) { +__declspec(noalias) void _Reverse_copy_vectorized(const void* _First, const void* _Last, void* _Dest) { if constexpr (_Nx == 1) { ::__std_reverse_copy_trivially_copyable_1(_First, _Last, _Dest); } else if constexpr (_Nx == 2) { @@ -4998,7 +4998,7 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) { if (!_STD is_constant_evaluated()) #endif // _HAS_CXX20 { - _STD _Reverse_copy_trivially_copyable<_Nx>( + _STD _Reverse_copy_vectorized<_Nx>( _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest)); _UDest += _ULast - _UFirst; _STD _Seek_wrapped(_Dest, _UDest); @@ -5075,7 +5075,7 @@ namespace ranges { if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) { if (!_STD is_constant_evaluated()) { - _STD _Reverse_copy_trivially_copyable<_Nx>( + _STD _Reverse_copy_vectorized<_Nx>( _STD to_address(_First), _STD to_address(_Last), _STD to_address(_Result)); _Result += _Last - _First; return _Result; From e6c38978e137f43c16a064fca8fc53c18505774a Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:56:50 -0700 Subject: [PATCH 18/27] `_Reverse_trivially_swappable` => `_Reverse_vectorized` --- stl/inc/algorithm | 2 +- stl/inc/xutility | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 65b3009e80..c8b9297f49 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -4939,7 +4939,7 @@ namespace ranges { if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) { if (!_STD is_constant_evaluated()) { - _STD _Reverse_trivially_swappable<_Nx>(_STD to_address(_First), _STD to_address(_Last)); + _STD _Reverse_vectorized<_Nx>(_STD to_address(_First), _STD to_address(_Last)); return; } } diff --git a/stl/inc/xutility b/stl/inc/xutility index d27cbca6cd..1b825ab862 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -133,7 +133,7 @@ __declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const _STD_BEGIN template -__declspec(noalias) void _Reverse_trivially_swappable(void* _First, void* _Last) noexcept { +__declspec(noalias) void _Reverse_vectorized(void* _First, void* _Last) noexcept { if constexpr (_Nx == 1) { ::__std_reverse_trivially_swappable_1(_First, _Last); } else if constexpr (_Nx == 2) { @@ -6330,7 +6330,7 @@ _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse if (!_STD is_constant_evaluated()) #endif // _HAS_CXX20 { - _STD _Reverse_trivially_swappable<_Nx>(_STD _To_address(_UFirst), _STD _To_address(_ULast)); + _STD _Reverse_vectorized<_Nx>(_STD _To_address(_UFirst), _STD _To_address(_ULast)); return; } } From a4bf8cce8568115ac9fd58998b99225764cd789b Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:57:48 -0700 Subject: [PATCH 19/27] `_Mismatch` => `_Mismatch_vectorized` --- stl/inc/algorithm | 4 ++-- stl/inc/xutility | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index c8b9297f49..77e495dafc 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -668,7 +668,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InI if (!_STD _Is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>); - const size_t _Pos = _STD _Mismatch<_Elem_size>( + const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>( _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast(_ULast1 - _UFirst1)); _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos); @@ -732,7 +732,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch( if (!_STD _Is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>); - const size_t _Pos = _STD _Mismatch<_Elem_size>( + const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>( _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast(_Count)); _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos); diff --git a/stl/inc/xutility b/stl/inc/xutility index 1b825ab862..a828c4af4d 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -325,7 +325,7 @@ auto _Max(_Ty* const _First, _Ty* const _Last) noexcept { template inline size_t // TRANSITION, GH-4496 - _Mismatch(const void* const _First1, const void* const _First2, const size_t _Count) noexcept { + _Mismatch_vectorized(const void* const _First1, const void* const _First2, const size_t _Count) noexcept { if constexpr (_Element_size == 1) { return __std_mismatch_1(_First1, _First2, _Count); } else if constexpr (_Element_size == 2) { @@ -5529,7 +5529,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { constexpr size_t _Elem_size = sizeof(iter_value_t<_It1>); - const size_t _Pos = _STD _Mismatch<_Elem_size>( + const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>( _STD _To_address(_First1), _STD _To_address(_First2), static_cast(_Count)); return {_First1 + static_cast>(_Pos), From 6261ae29de26732d69018356c89543900f1d0dfe Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 05:59:46 -0700 Subject: [PATCH 20/27] `_Min_element` => `_Min_element_vectorized` --- stl/inc/xutility | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/xutility b/stl/inc/xutility index a828c4af4d..74ac06505e 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -196,7 +196,7 @@ _Ty* _Find_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noe } template -_Ty* _Min_element(_Ty* const _First, _Ty* const _Last) noexcept { +_Ty* _Min_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_same_v, float>) { @@ -7001,7 +7001,7 @@ constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD _Min_element(_First_ptr, _STD _To_address(_Last)); + const auto _Result = _STD _Min_element_vectorized(_First_ptr, _STD _To_address(_Last)); if constexpr (is_pointer_v<_FwdIt>) { return _Result; } else { @@ -7067,7 +7067,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD _Min_element(_First_ptr, _Last_ptr); + const auto _Result = _STD _Min_element_vectorized(_First_ptr, _Last_ptr); if constexpr (is_pointer_v<_It>) { return _Result; } else { From 0a9b95ffe90d342efb794bbadae37cf57e26e01a Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 06:00:22 -0700 Subject: [PATCH 21/27] `_Max_element` => `_Max_element_vectorized` --- stl/inc/xutility | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/xutility b/stl/inc/xutility index 74ac06505e..058f2827a5 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -217,7 +217,7 @@ _Ty* _Min_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { } template -_Ty* _Max_element(_Ty* const _First, _Ty* const _Last) noexcept { +_Ty* _Max_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_same_v, float>) { @@ -6777,7 +6777,7 @@ constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD _Max_element(_First_ptr, _STD _To_address(_Last)); + const auto _Result = _STD _Max_element_vectorized(_First_ptr, _STD _To_address(_Last)); if constexpr (is_pointer_v<_FwdIt>) { return _Result; } else { @@ -6843,7 +6843,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD _Max_element(_First_ptr, _Last_ptr); + const auto _Result = _STD _Max_element_vectorized(_First_ptr, _Last_ptr); if constexpr (is_pointer_v<_It>) { return _Result; } else { From 193c5a471e25b1fb25cb1faca019b039c05733aa Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 06:01:16 -0700 Subject: [PATCH 22/27] `_Minmax_element` => `_Minmax_element_vectorized` --- stl/inc/algorithm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 77e495dafc..b351aed3a8 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -92,7 +92,7 @@ __declspec(noalias) void _Reverse_copy_vectorized(const void* _First, const void } template -pair<_Ty*, _Ty*> _Minmax_element(_Ty* const _First, _Ty* const _Last) noexcept { +pair<_Ty*, _Ty*> _Minmax_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; _Min_max_element_t _Res; @@ -10035,7 +10035,7 @@ constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _ if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) { if (!_Is_constant_evaluated()) { const auto _First_ptr = _STD _To_address(_First); - const auto _Result = _STD _Minmax_element(_First_ptr, _STD _To_address(_Last)); + const auto _Result = _STD _Minmax_element_vectorized(_First_ptr, _STD _To_address(_Last)); if constexpr (is_pointer_v<_FwdIt>) { return _Result; } else { @@ -10162,7 +10162,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD _Minmax_element(_First_ptr, _Last_ptr); + const auto _Result = _STD _Minmax_element_vectorized(_First_ptr, _Last_ptr); if constexpr (is_pointer_v<_It>) { return {_Result.first, _Result.second}; } else { From b4bfc3216a2ddc043714351b647c5bc7aa9ea35d Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 06:06:47 -0700 Subject: [PATCH 23/27] `_Min(` => `_Min_vectorized(` in `` --- stl/inc/xutility | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/stl/inc/xutility b/stl/inc/xutility index 058f2827a5..314f1ff1aa 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -238,7 +238,7 @@ _Ty* _Max_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { } template -auto _Min(_Ty* const _First, _Ty* const _Last) noexcept { +auto _Min_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_pointer_v<_Ty>) { @@ -7127,7 +7127,7 @@ _NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (_Is_min_max_optimization_safe) { if (!_Is_constant_evaluated()) { - return static_cast<_Ty>(_STD _Min(_Ilist.begin(), _Ilist.end())); + return static_cast<_Ty>(_STD _Min_vectorized(_Ilist.begin(), _Ilist.end())); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -7167,7 +7167,7 @@ namespace ranges { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe) { if (!_STD is_constant_evaluated()) { - return static_cast<_Ty>(_STD _Min(_First, _Last)); + return static_cast<_Ty>(_STD _Min_vectorized(_First, _Last)); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -7189,7 +7189,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_UFirst); const auto _Last_ptr = _First_ptr + (_ULast - _UFirst); - return static_cast>(_STD _Min(_First_ptr, _Last_ptr)); + return static_cast>(_STD _Min_vectorized(_First_ptr, _Last_ptr)); } } #endif // _USE_STD_VECTOR_ALGORITHMS From 8f0d5ae85387540106758a2d4c3ad40e5fda070b Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 06:07:29 -0700 Subject: [PATCH 24/27] `_Max(` => `_Max_vectorized(` in `` --- stl/inc/xutility | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/stl/inc/xutility b/stl/inc/xutility index 314f1ff1aa..6e96021217 100644 --- a/stl/inc/xutility +++ b/stl/inc/xutility @@ -281,7 +281,7 @@ auto _Min_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { } template -auto _Max(_Ty* const _First, _Ty* const _Last) noexcept { +auto _Max_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_pointer_v<_Ty>) { @@ -6903,7 +6903,7 @@ _NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (_Is_min_max_optimization_safe) { if (!_Is_constant_evaluated()) { - return static_cast<_Ty>(_STD _Max(_Ilist.begin(), _Ilist.end())); + return static_cast<_Ty>(_STD _Max_vectorized(_Ilist.begin(), _Ilist.end())); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -6949,7 +6949,7 @@ namespace ranges { #if _USE_STD_VECTOR_ALGORITHMS if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe) { if (!_STD is_constant_evaluated()) { - return static_cast<_Ty>(_STD _Max(_First, _Last)); + return static_cast<_Ty>(_STD _Max_vectorized(_First, _Last)); } } #endif // _USE_STD_VECTOR_ALGORITHMS @@ -6971,7 +6971,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_UFirst); const auto _Last_ptr = _First_ptr + (_ULast - _UFirst); - return static_cast>(_STD _Max(_First_ptr, _Last_ptr)); + return static_cast>(_STD _Max_vectorized(_First_ptr, _Last_ptr)); } } #endif // _USE_STD_VECTOR_ALGORITHMS From 4d92cd59a55c7f8694341da5aa1db50592d641c9 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 06:08:06 -0700 Subject: [PATCH 25/27] `_Minmax` => `_Minmax_vectorized` --- stl/inc/algorithm | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index b351aed3a8..00f4cb54e9 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -117,7 +117,7 @@ pair<_Ty*, _Ty*> _Minmax_element_vectorized(_Ty* const _First, _Ty* const _Last) } template -auto _Minmax(_Ty* const _First, _Ty* const _Last) noexcept { +auto _Minmax_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { constexpr bool _Signed = is_signed_v<_Ty>; if constexpr (is_pointer_v<_Ty>) { @@ -10240,7 +10240,7 @@ _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pr #if _USE_STD_VECTOR_ALGORITHMS if constexpr (_Is_min_max_optimization_safe) { if (!_STD _Is_constant_evaluated()) { - const auto _Result = _STD _Minmax(_Ilist.begin(), _Ilist.end()); + const auto _Result = _STD _Minmax_vectorized(_Ilist.begin(), _Ilist.end()); return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)}; } } @@ -10372,7 +10372,7 @@ namespace ranges { if (!_STD is_constant_evaluated()) { const auto _First_ptr = _STD to_address(_First); const auto _Last_ptr = _First_ptr + (_Last - _First); - const auto _Result = _STD _Minmax(_First_ptr, _Last_ptr); + const auto _Result = _STD _Minmax_vectorized(_First_ptr, _Last_ptr); return {static_cast<_Vty>(_Result._Min), static_cast<_Vty>(_Result._Max)}; } } From f88de777fa0f086e2e21618840455750acdfaf34 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 06:37:57 -0700 Subject: [PATCH 26/27] Restore and rename `__std_find_last_trivial` => `_Find_last_vectorized` --- stl/inc/algorithm | 49 +++++++++++++++++++++-------------------------- 1 file changed, 22 insertions(+), 27 deletions(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index 00f4cb54e9..abe684025a 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -160,6 +160,27 @@ auto _Minmax_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { } } +template +_Ty* _Find_last_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { + if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { + return _STD _Find_last_vectorized(_First, _Last, reinterpret_cast(_Val)); + } else if constexpr (sizeof(_Ty) == 1) { + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_1(_First, _Last, static_cast(_Val)))); + } else if constexpr (sizeof(_Ty) == 2) { + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_2(_First, _Last, static_cast(_Val)))); + } else if constexpr (sizeof(_Ty) == 4) { + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_4(_First, _Last, static_cast(_Val)))); + } else if constexpr (sizeof(_Ty) == 8) { + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_8(_First, _Last, static_cast(_Val)))); + } else { + static_assert(_Always_false<_Ty>, "Unexpected size"); + } +} + template _Ty1* _Find_first_of_vectorized( _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept { @@ -2970,33 +2991,7 @@ namespace ranges { const auto _First_ptr = _STD _To_address(_First); const auto _Last_ptr = _First_ptr + _Count; - using _TVal = iter_value_t<_It>; - _TVal* _Result; - - if constexpr (is_pointer_v<_Ty> || is_null_pointer_v<_Ty>) { -#ifdef _WIN64 - _Result = const_cast<_TVal*>(static_cast( - ::__std_find_last_trivial_8(_First_ptr, _Last_ptr, reinterpret_cast(_Value)))); -#else - _Result = const_cast<_TVal*>(static_cast( - ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, reinterpret_cast(_Value)))); -#endif - } else if constexpr (sizeof(_TVal) == 1) { - _Result = const_cast<_TVal*>(static_cast( - ::__std_find_last_trivial_1(_First_ptr, _Last_ptr, static_cast(_Value)))); - } else if constexpr (sizeof(_TVal) == 2) { - _Result = const_cast<_TVal*>(static_cast( - ::__std_find_last_trivial_2(_First_ptr, _Last_ptr, static_cast(_Value)))); - } else if constexpr (sizeof(_TVal) == 4) { - _Result = const_cast<_TVal*>(static_cast( - ::__std_find_last_trivial_4(_First_ptr, _Last_ptr, static_cast(_Value)))); - } else if constexpr (sizeof(_TVal) == 8) { - _Result = const_cast<_TVal*>(static_cast( - ::__std_find_last_trivial_8(_First_ptr, _Last_ptr, static_cast(_Value)))); - } else { - static_assert(_Always_false<_Ty>, "Unexpected size"); - } - + const auto _Result = _STD _Find_last_vectorized(_First_ptr, _Last_ptr, _Value); if constexpr (is_pointer_v<_It>) { return {_Result, _Last_ptr}; } else { From 33267180e4a85d74adbf3dcabe0c5690fb92dc71 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 3 Apr 2024 06:43:53 -0700 Subject: [PATCH 27/27] Handle `_WIN64` in `_Find_last_vectorized` without recursing. --- stl/inc/algorithm | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/stl/inc/algorithm b/stl/inc/algorithm index abe684025a..29672ceb0f 100644 --- a/stl/inc/algorithm +++ b/stl/inc/algorithm @@ -163,7 +163,13 @@ auto _Minmax_vectorized(_Ty* const _First, _Ty* const _Last) noexcept { template _Ty* _Find_last_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept { if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) { - return _STD _Find_last_vectorized(_First, _Last, reinterpret_cast(_Val)); +#ifdef _WIN64 + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_8(_First, _Last, reinterpret_cast(_Val)))); +#else + return const_cast<_Ty*>( + static_cast(::__std_find_last_trivial_4(_First, _Last, reinterpret_cast(_Val)))); +#endif } else if constexpr (sizeof(_Ty) == 1) { return const_cast<_Ty*>( static_cast(::__std_find_last_trivial_1(_First, _Last, static_cast(_Val))));