Skip to content

Commit

Permalink
Use _Memop_in_algorithm_is_safe
Browse files Browse the repository at this point in the history
  • Loading branch information
@miscco
miscco committed Oct 7, 2020
1 parent c6fbaec commit 8a9f343
Show file tree
Hide file tree
Showing 6 changed files with 139 additions and 132 deletions.
14 changes: 7 additions & 7 deletions stl/inc/algorithm
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1850,7 +1850,7 @@ namespace ranges {
template <bidirectional_iterator _It1, bidirectional_iterator _It2>
requires indirectly_movable<_It1, _It2>
_NODISCARD constexpr _It2 _Move_backward_common(const _It1 _First, _It1 _Last, _It2 _Result) {
if constexpr (_Can_memmove_in_move<_It1, _It2>) {
if constexpr (_Memmove_in_move_is_safe<_It1, _It2>) {
if (!_STD is_constant_evaluated()) {
return _Copy_backward_memmove(_First, _Last, _Result);
}
Expand Down Expand Up @@ -2217,7 +2217,7 @@ namespace ranges {
template <class _InIt1, class _InIt2, class _Pr>
_NODISCARD _CONSTEXPR20 bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
// compare [_First1, ...) to [_First2, _Last2)
if constexpr (_Can_memcmp_in_equal<_InIt1, _InIt2, _Pr>) {
if constexpr (_Memcmp_in_equal_is_safe<_InIt1, _InIt2, _Pr>) {
#ifdef __cpp_lib_is_constant_evaluated
if (!_STD is_constant_evaluated())
#endif // __cpp_lib_is_constant_evaluated
Expand All @@ -2238,7 +2238,7 @@ _NODISCARD _CONSTEXPR20 bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _F
return true;
}
#else // ^^^ _HAS_IF_CONSTEXPR ^^^ // vvv !_HAS_IF_CONSTEXPR vvv
template <class _InIt1, class _InIt2, class _Pr, enable_if_t<!_Can_memcmp_in_equal<_InIt1, _InIt2, _Pr>, int> = 0>
template <class _InIt1, class _InIt2, class _Pr, enable_if_t<!_Memcmp_in_equal_is_safe<_InIt1, _InIt2, _Pr>, int> = 0>
bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
// compare [_First1, ...) to [_First2, _Last2), no special optimization
for (; _First2 != _Last2; ++_First1, (void) ++_First2) {
Expand All @@ -2250,7 +2250,7 @@ bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _First2, const _InIt2 _Las
return true;
}

template <class _InIt1, class _InIt2, class _Pr, enable_if_t<_Can_memcmp_in_equal<_InIt1, _InIt2, _Pr>, int> = 0>
template <class _InIt1, class _InIt2, class _Pr, enable_if_t<_Memcmp_in_equal_is_safe<_InIt1, _InIt2, _Pr>, int> = 0>
bool _Equal_rev_pred_unchecked(const _InIt1 _First1, const _InIt2 _First2, const _InIt2 _Last2, _Pr) {
// compare [_First1, ...) to [_First2, _Last2), memcmp optimization
const auto _First1_ch = reinterpret_cast<const char*>(_First1);
Expand Down Expand Up @@ -2391,7 +2391,7 @@ namespace ranges {
// clang-format off
template <class _It1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
concept _Equal_rev_pred_can_memcmp = is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>
&& is_same_v<_Se2, _It2> && _Can_memcmp_in_equal<_It1, _It2, _Pr>;
&& is_same_v<_Se2, _It2> && _Memcmp_in_equal_is_safe<_It1, _It2, _Pr>;

template <input_iterator _It1, input_iterator _It2, sentinel_for<_It2> _Se2, class _Pr, class _Pj1, class _Pj2>
requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
Expand Down Expand Up @@ -3938,7 +3938,7 @@ namespace ranges {
_Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_STD move(_First));
const auto _ULast = _Get_unwrapped(_STD move(_Last));
if constexpr (_Can_memset_in_fill<decltype(_UFirst), _Ty>) {
if constexpr (_Memset_in_fill_is_safe<decltype(_UFirst), _Ty>) {
#ifdef __cpp_lib_is_constant_evaluated
if (!_STD is_constant_evaluated())
#endif // __cpp_lib_is_constant_evaluated
Expand Down Expand Up @@ -3978,7 +3978,7 @@ namespace ranges {
constexpr _It operator()(_It _First, iter_difference_t<_It> _Count, const _Ty& _Value) const {
if (_Count > 0) {
auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count);
if constexpr (_Can_memset_in_fill<decltype(_UFirst), _Ty>) {
if constexpr (_Memset_in_fill_is_safe<decltype(_UFirst), _Ty>) {
#ifdef __cpp_lib_is_constant_evaluated
if (!_STD is_constant_evaluated())
#endif // __cpp_lib_is_constant_evaluated
Expand Down
30 changes: 16 additions & 14 deletions stl/inc/memory
View file
Original file line number Diff line number Diff line change
Expand Up @@ -107,7 +107,7 @@ namespace ranges {
_STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_OSe, _Out>);
_STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_Out>, iter_reference_t<_It>>);

if constexpr (is_same_v<_Se, _It> && _Can_memmove_in_uninitialized_copy<_It, _Out>) {
if constexpr (is_same_v<_Se, _It> && _Memmove_in_uninitialized_copy_is_safe<_It, _Out>) {
return _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast);
} else {
_Uninitialized_backout _Backout{_STD move(_OFirst)};
Expand Down Expand Up @@ -137,7 +137,7 @@ _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _

auto _UFirst = _Get_unwrapped_n(_First, _Count);
auto _UDest = _Get_unwrapped_n(_Dest, _Count);
if constexpr (_Can_memmove_in_uninitialized_copy<decltype(_UFirst), decltype(_UDest)>) {
if constexpr (_Memmove_in_uninitialized_copy_is_safe<decltype(_UFirst), decltype(_UDest)>) {
_UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
} else {
_Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
Expand Down Expand Up @@ -181,8 +181,9 @@ _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _

auto _UFirst = _Get_unwrapped_n(_First, _Count);
auto _UDest = _Get_unwrapped_n(_Dest, _Count);
_Seek_wrapped(_Dest, _Uninitialized_copy_n_unchecked2(_UFirst, _Count, _UDest,
bool_constant<_Can_memmove_in_uninitialized_copy<decltype(_UFirst), decltype(_UDest)>>{}));
_Seek_wrapped(
_Dest, _Uninitialized_copy_n_unchecked2(_UFirst, _Count, _UDest,
bool_constant<_Memmove_in_uninitialized_copy_is_safe<decltype(_UFirst), decltype(_UDest)>>{}));
return _Dest;
}
#endif // _HAS_IF_CONSTEXPR
Expand Down Expand Up @@ -212,7 +213,7 @@ namespace ranges {
auto _IFirst = _Get_unwrapped_n(_STD move(_First1), _Count);
auto _OFirst = _Get_unwrapped(_STD move(_First2));
const auto _OLast = _Get_unwrapped(_STD move(_Last2));
if constexpr (_Can_memmove_in_uninitialized_copy<_It, _Out>) {
if constexpr (_Memmove_in_uninitialized_copy_is_safe<_It, _Out>) {
_OFirst = _Copy_memcpy_common(_IFirst, _IFirst + _Count, _OFirst, _OLast);
} else {
_Uninitialized_backout _Backout{_STD move(_OFirst)};
Expand Down Expand Up @@ -299,7 +300,7 @@ namespace ranges {
_STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_OSe, _Out>);
_STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>);

if constexpr (is_same_v<_Se, _It> && _Can_memmove_in_uninitialized_move<_It, _Out>) {
if constexpr (is_same_v<_Se, _It> && _Memmove_in_uninitialized_move_is_safe<_It, _Out>) {
return _Copy_memcpy_common(_IFirst, _ILast, _OFirst, _OLast);
} else {
_Uninitialized_backout _Backout{_STD move(_OFirst)};
Expand Down Expand Up @@ -328,7 +329,7 @@ pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count

auto _UFirst = _Get_unwrapped_n(_First, _Count);
auto _UDest = _Get_unwrapped_n(_Dest, _Count);
if constexpr (_Can_memmove_in_uninitialized_move<decltype(_UFirst), decltype(_UDest)>) {
if constexpr (_Memmove_in_uninitialized_move_is_safe<decltype(_UFirst), decltype(_UDest)>) {
_UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
_UFirst += _Count;
} else {
Expand Down Expand Up @@ -373,7 +374,7 @@ namespace ranges {
auto _IFirst = _Get_unwrapped_n(_STD move(_First1), _Count);
auto _OFirst = _Get_unwrapped(_STD move(_First2));
const auto _OLast = _Get_unwrapped(_STD move(_Last2));
if constexpr (_Can_memmove_in_uninitialized_move<_It, _Out>) {
if constexpr (_Memmove_in_uninitialized_move_is_safe<_It, _Out>) {
_OFirst = _Copy_memcpy_common(_IFirst, _IFirst + _Count, _OFirst, _OLast);
} else {
_Uninitialized_backout _Backout{_STD move(_OFirst)};
Expand Down Expand Up @@ -426,7 +427,7 @@ namespace ranges {
_STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_Se, _It>);
_STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_It>, const _Ty&>);

if constexpr (_Can_memset_in_fill<_It, _Ty>) {
if constexpr (_Memset_in_fill_is_safe<_It, _Ty>) {
const auto _OFinal = _RANGES next(_OFirst, _STD move(_OLast));
const auto _Diff = static_cast<size_t>(_OFinal - _OFirst);
_Fill_memset(_OFirst, _Val, _Diff);
Expand Down Expand Up @@ -458,7 +459,7 @@ _NoThrowFwdIt uninitialized_fill_n(_NoThrowFwdIt _First, const _Diff _Count_raw,
}

auto _UFirst = _Get_unwrapped_n(_First, _Count);
if constexpr (_Can_memset_in_fill<_Unwrapped_n_t<const _NoThrowFwdIt&>, _Tval>) {
if constexpr (_Memset_in_fill_is_safe<_Unwrapped_n_t<const _NoThrowFwdIt&>, _Tval>) {
_Fill_memset(_UFirst, _Val, static_cast<size_t>(_Count));
_UFirst += _Count;
} else {
Expand Down Expand Up @@ -505,7 +506,7 @@ _NoThrowFwdIt uninitialized_fill_n(_NoThrowFwdIt _First, const _Diff _Count_raw,

auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count);
_Seek_wrapped(_First, _Uninitialized_fill_n_unchecked1(_STD move(_UFirst), _Count, _Val,
bool_constant<_Can_memset_in_fill<_Unwrapped_t<_NoThrowFwdIt>, _Tval>>{}));
bool_constant<_Memset_in_fill_is_safe<_Unwrapped_t<_NoThrowFwdIt>, _Tval>>{}));
return _First;
}
#endif // _HAS_IF_CONSTEXPR
Expand All @@ -527,7 +528,7 @@ namespace ranges {
}

auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count);
if constexpr (_Can_memset_in_fill<_It, _Ty>) {
if constexpr (_Memset_in_fill_is_safe<_It, _Ty>) {
_Fill_memset(_UFirst, _Val, static_cast<size_t>(_Count));
_Seek_wrapped(_First, _UFirst + _Count);
} else {
Expand Down Expand Up @@ -2359,7 +2360,7 @@ void _Uninitialized_fill_multidimensional_n(_Ty* const _Out, const size_t _Size,
_Uninitialized_copy_multidimensional(_Val, _Out[_Idx]); // intentionally copy, not fill
}
_Guard._Target = nullptr;
} else if constexpr (_Can_memset_in_fill<_Ty*, _Ty>) {
} else if constexpr (_Memset_in_fill_is_safe<_Ty*, _Ty>) {
_Fill_memset(_Out, _Val, _Size);
} else {
_Uninitialized_rev_destroying_backout _Backout{_Out};
Expand Down Expand Up @@ -2682,7 +2683,8 @@ void _Uninitialized_fill_multidimensional_n_al(_Ty* const _Out, const size_t _Si
_Uninitialized_copy_multidimensional_al(_Val, _Out[_Idx], _Al); // intentionally copy, not fill
}
_Guard._Target = nullptr;
} else if constexpr (_Can_memset_in_fill<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, const _Ty&>::value) {
} else if constexpr (_Memset_in_fill_is_safe<_Ty*,
_Ty> && _Uses_default_construct<_Alloc, _Ty*, const _Ty&>::value) {
_Fill_memset(_Out, _Val, _Size);
} else {
_Uninitialized_rev_destroying_backout_al _Backout{_Out, _Al};
Expand Down
4 changes: 2 additions & 2 deletions stl/inc/vector
View file
Original file line number Diff line number Diff line change
Expand Up @@ -636,7 +636,7 @@ private:

const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
#if _HAS_IF_CONSTEXPR
if constexpr (conjunction_v<bool_constant<_Can_memmove_in_copy<_Ty*, _Ty*>>,
if constexpr (conjunction_v<bool_constant<_Memmove_in_copy_is_safe<_Ty*, _Ty*>>,
_Uses_default_construct<_Alty, _Ty*, _Ty>, _Uses_default_destroy<_Alty, _Ty*>>) {
if (_Newsize > _Oldcapacity) {
_Clear_and_reserve_geometric(_Newsize);
Expand Down Expand Up @@ -1108,7 +1108,7 @@ private:
_My_data._Orphan_all();

#if _HAS_IF_CONSTEXPR
if constexpr (conjunction_v<bool_constant<_Can_memmove_in_copy<_Iter, _Ty*>>,
if constexpr (conjunction_v<bool_constant<_Memmove_in_copy_is_safe<_Iter, _Ty*>>,
_Uses_default_construct<_Alty, _Ty*, decltype(*_First)>,
_Uses_default_destroy<_Alty, _Ty*>>) {
const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
Expand Down
27 changes: 14 additions & 13 deletions stl/inc/xmemory
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1480,7 +1480,7 @@ namespace ranges {
template <class _InIt, class _NoThrowFwdIt>
_NoThrowFwdIt _Uninitialized_move_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
// move [_First, _Last) to raw [_Dest, ...)
if constexpr (_Can_memmove_in_uninitialized_move<_InIt, _NoThrowFwdIt>) {
if constexpr (_Memmove_in_uninitialized_move_is_safe<_InIt, _NoThrowFwdIt>) {
return _Copy_memmove(_First, _Last, _Dest);
} else {
_Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
Expand Down Expand Up @@ -1514,7 +1514,7 @@ template <class _InIt, class _NoThrowFwdIt>
_NoThrowFwdIt _Uninitialized_move_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
// move [_First, _Last) to raw [_Dest, ...), choose optimization
return _Uninitialized_move_unchecked1(
_First, _Last, _Dest, bool_constant<_Can_memmove_in_uninitialized_move<_InIt, _NoThrowFwdIt>>{});
_First, _Last, _Dest, bool_constant<_Memmove_in_uninitialized_move_is_safe<_InIt, _NoThrowFwdIt>>{});
}
#endif // _HAS_IF_CONSTEXPR

Expand Down Expand Up @@ -1562,7 +1562,7 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last);

if constexpr (conjunction_v<bool_constant<_Can_memmove_in_uninitialized_copy<decltype(_UFirst), _Ptrval>>,
if constexpr (conjunction_v<bool_constant<_Memmove_in_uninitialized_copy_is_safe<decltype(_UFirst), _Ptrval>>,
_Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>) {
_Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
_Dest += _ULast - _UFirst;
Expand Down Expand Up @@ -1610,7 +1610,7 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_copy(

using _Ptrval = typename _Alloc::value_type*;
return _Uninitialized_copy_al_unchecked(_UFirst, _ULast, _Dest, _Al,
bool_constant<conjunction_v<bool_constant<_Can_memmove_in_uninitialized_copy<decltype(_UFirst), _Ptrval>>,
bool_constant<conjunction_v<bool_constant<_Memmove_in_uninitialized_copy_is_safe<decltype(_UFirst), _Ptrval>>,
_Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>>{});
}
#endif // _HAS_IF_CONSTEXPR
Expand All @@ -1624,7 +1624,7 @@ _NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrow
auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last);
auto _UDest = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
if constexpr (_Can_memmove_in_uninitialized_copy<decltype(_UFirst), decltype(_UDest)>) {
if constexpr (_Memmove_in_uninitialized_copy_is_safe<decltype(_UFirst), decltype(_UDest)>) {
_UDest = _Copy_memmove(_UFirst, _ULast, _UDest);
} else {
_Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
Expand Down Expand Up @@ -1664,8 +1664,9 @@ _NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrow
auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last);
auto _UDest = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
_Seek_wrapped(_Dest, _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest,
bool_constant<_Can_memmove_in_uninitialized_copy<decltype(_UFirst), decltype(_UDest)>>{}));
_Seek_wrapped(
_Dest, _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest,
bool_constant<_Memmove_in_uninitialized_copy_is_safe<decltype(_UFirst), decltype(_UDest)>>{}));
return _Dest;
}
#endif // _HAS_IF_CONSTEXPR
Expand All @@ -1680,7 +1681,7 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_move(
using _Ptrval = typename _Alloc::value_type*;
auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last);
if constexpr (conjunction_v<bool_constant<_Can_memmove_in_uninitialized_move<decltype(_UFirst), _Ptrval>>,
if constexpr (conjunction_v<bool_constant<_Memmove_in_uninitialized_move_is_safe<decltype(_UFirst), _Ptrval>>,
_Uses_default_construct<_Alloc, _Ptrval, decltype(_STD move(*_UFirst))>>) {
_Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
return _Dest + (_ULast - _UFirst);
Expand Down Expand Up @@ -1729,7 +1730,7 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_move(
using _Ptrval = typename _Alloc::value_type*;
_Seek_wrapped(_Dest,
_Uninitialized_move_al_unchecked(_UFirst, _ULast, _UDest, _Al,
bool_constant < _Can_memmove_in_uninitialized_move<decltype(_UFirst),
bool_constant < _Memmove_in_uninitialized_move_is_safe<decltype(_UFirst),
_Ptrval> && _Uses_default_construct<_Alloc, _Ptrval, decltype(_STD move(*_UFirst))>::value > {}));
return _Dest;
}
Expand All @@ -1742,7 +1743,7 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
_Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, const typename _Alloc::value_type& _Val, _Alloc& _Al) {
// copy _Count copies of _Val to raw _First, using _Al
using _Ty = typename _Alloc::value_type;
if constexpr (_Can_memset_in_fill<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
if constexpr (_Memset_in_fill_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
_Fill_memset(_Unfancy(_First), _Val, static_cast<size_t>(_Count));
return _First + _Count;
} else {
Expand Down Expand Up @@ -1781,7 +1782,7 @@ _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(_Alloc_ptr_t<_Alloc> _First, const _A
// copy _Count copies of _Val to raw _First, using _Al
using _Ty = typename _Alloc::value_type;
return _Uninit_alloc_fill_n1(_First, _Count, _Val, _Al,
bool_constant < _Can_memset_in_fill<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value > {});
bool_constant < _Memset_in_fill_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value > {});
}
#endif // _HAS_IF_CONSTEXPR

Expand All @@ -1793,7 +1794,7 @@ void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, c
_Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last);
if constexpr (_Can_memset_in_fill<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
if constexpr (_Memset_in_fill_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
_Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
} else {
_Uninitialized_backout<_Unwrapped_t<const _NoThrowFwdIt&>> _Backout{_UFirst};
Expand Down Expand Up @@ -1830,7 +1831,7 @@ void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, c
_Adl_verify_range(_First, _Last);
const auto _UFirst = _Get_unwrapped(_First);
_Uninitialized_fill_unchecked(_UFirst, _Get_unwrapped(_Last), _Val,
bool_constant<_Can_memset_in_fill<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>>{});
bool_constant<_Memset_in_fill_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>>{});
}
#endif // _HAS_IF_CONSTEXPR

Expand Down
Loading

0 comments on commit 8a9f343

Please sign in to comment.