* [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h>
@ 2020-02-12 20:42 Patrick Palka
2020-02-12 20:42 ` [PATCH 2/2] libstdc++: Implement ranges [specialized.algorithms] Patrick Palka
2020-02-13 12:20 ` [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h> Jonathan Wakely
0 siblings, 2 replies; 5+ messages in thread
From: Patrick Palka @ 2020-02-12 20:42 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, jwakely, Patrick Palka
This roughly mirrors the existing split between <bits/stl_algo.h> and
<bits/stl_algobase.h>. The ranges [specialized.algorithms] will use this new
header to avoid including all of of <bits/ranges_algo.h>.
libstdc++-v3/ChangeLog:
* include/Makefile.am: Add bits/ranges_algobase.h
* include/Makefile.in: Regenerate.
* bits/ranges_algo.h: Include <bits/ranges_algobase.h> and refactor
existing #includes.
(__detail::__is_normal_iterator, __detail::is_reverse_iterator,
__detail::__is_move_iterator, copy_result, move_result,
__equal, equal, copy_result, move_result, move_backward_result,
copy_backward_result, __copy_or_move_backward, __copy_or_move, copy,
move, copy_backward, move_backward, copy_n_result, copy_n, fill_n,
fill): Split out into ...
* bits/range_algobase.h: ... this new header.
---
libstdc++-v3/include/Makefile.am | 1 +
libstdc++-v3/include/Makefile.in | 1 +
libstdc++-v3/include/bits/ranges_algo.h | 508 +-----------------
libstdc++-v3/include/bits/ranges_algobase.h | 556 ++++++++++++++++++++
4 files changed, 559 insertions(+), 507 deletions(-)
create mode 100644 libstdc++-v3/include/bits/ranges_algobase.h
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 1d342cecbcc..614222db400 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -157,6 +157,7 @@ bits_headers = \
${bits_srcdir}/random.tcc \
${bits_srcdir}/range_access.h \
${bits_srcdir}/range_cmp.h \
+ ${bits_srcdir}/ranges_algobase.h \
${bits_srcdir}/ranges_algo.h \
${bits_srcdir}/refwrap.h \
${bits_srcdir}/regex.h \
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index c735d67a5d3..7ee6a1e3f61 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -502,6 +502,7 @@ bits_headers = \
${bits_srcdir}/random.tcc \
${bits_srcdir}/range_access.h \
${bits_srcdir}/range_cmp.h \
+ ${bits_srcdir}/ranges_algobase.h \
${bits_srcdir}/ranges_algo.h \
${bits_srcdir}/refwrap.h \
${bits_srcdir}/regex.h \
diff --git a/libstdc++-v3/include/bits/ranges_algo.h b/libstdc++-v3/include/bits/ranges_algo.h
index e065ff2a974..84a02cabb80 100644
--- a/libstdc++-v3/include/bits/ranges_algo.h
+++ b/libstdc++-v3/include/bits/ranges_algo.h
@@ -32,13 +32,7 @@
#if __cplusplus > 201703L
-#include <compare>
-#include <cmath>
-#include <iterator>
-// #include <bits/range_concepts.h>
-#include <ranges>
-#include <bits/invoke.h>
-#include <bits/cpp_type_traits.h> // __is_byte
+#include <bits/ranges_algobase.h>
#include <bits/random.h> // concept uniform_random_bit_generator
#if __cpp_lib_concepts
@@ -49,28 +43,6 @@ namespace ranges
{
namespace __detail
{
- template<typename _Tp>
- constexpr inline bool __is_normal_iterator = false;
-
- template<typename _Iterator, typename _Container>
- constexpr inline bool
- __is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator,
- _Container>> = true;
-
- template<typename _Tp>
- constexpr inline bool __is_reverse_iterator = false;
-
- template<typename _Iterator>
- constexpr inline bool
- __is_reverse_iterator<reverse_iterator<_Iterator>> = true;
-
- template<typename _Tp>
- constexpr inline bool __is_move_iterator = false;
-
- template<typename _Iterator>
- constexpr inline bool
- __is_move_iterator<move_iterator<_Iterator>> = true;
-
template<typename _Comp, typename _Proj>
constexpr auto
__make_comp_proj(_Comp& __comp, _Proj& __proj)
@@ -741,420 +713,6 @@ namespace ranges
std::move(__proj1), std::move(__proj2));
}
- template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
- input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
- typename _Pred, typename _Proj1, typename _Proj2>
- requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
- constexpr bool
- __equal(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
- _Pred __pred, _Proj1 __proj1, _Proj2 __proj2)
- {
- // TODO: implement more specializations to at least have parity with
- // std::equal.
- constexpr bool __sized_iters
- = (sized_sentinel_for<_Sent1, _Iter1>
- && sized_sentinel_for<_Sent2, _Iter2>);
- if constexpr (__sized_iters)
- {
- auto __d1 = ranges::distance(__first1, __last1);
- auto __d2 = ranges::distance(__first2, __last2);
- if (__d1 != __d2)
- return false;
-
- using _ValueType1 = iter_value_t<_Iter1>;
- using _ValueType2 = iter_value_t<_Iter2>;
- constexpr bool __use_memcmp
- = ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
- && is_same_v<_ValueType1, _ValueType2>
- && is_pointer_v<_Iter1>
- && is_pointer_v<_Iter2>
- && is_same_v<_Pred, ranges::equal_to>
- && is_same_v<_Proj1, identity>
- && is_same_v<_Proj2, identity>);
- if constexpr (__use_memcmp)
- {
- if (const size_t __len = (__last1 - __first1))
- return !std::__memcmp(__first1, __first2, __len);
- return true;
- }
- else
- {
- for (; __first1 != __last1; ++__first1, (void)++__first2)
- if (!(bool)std::__invoke(__pred,
- std::__invoke(__proj1, *__first1),
- std::__invoke(__proj2, *__first2)))
- return false;
- return true;
- }
- }
- else
- {
- for (; __first1 != __last1 && __first2 != __last2;
- ++__first1, (void)++__first2)
- if (!(bool)std::__invoke(__pred,
- std::__invoke(__proj1, *__first1),
- std::__invoke(__proj2, *__first2)))
- return false;
- return __first1 == __last1 && __first2 == __last2;
- }
- }
-
- template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
- input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
- typename _Pred = ranges::equal_to,
- typename _Proj1 = identity, typename _Proj2 = identity>
- requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
- constexpr bool
- equal(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
- _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
- {
- return ranges::__equal(std::__niter_base(std::move(__first1)),
- std::__niter_base(std::move(__last1)),
- std::__niter_base(std::move(__first2)),
- std::__niter_base(std::move(__last2)),
- std::move(__pred),
- std::move(__proj1), std::move(__proj2));
- }
-
- template<input_range _Range1, input_range _Range2,
- typename _Pred = ranges::equal_to,
- typename _Proj1 = identity, typename _Proj2 = identity>
- requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
- _Pred, _Proj1, _Proj2>
- constexpr bool
- equal(_Range1&& __r1, _Range2&& __r2,
- _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
- {
- return ranges::equal(ranges::begin(__r1), ranges::end(__r1),
- ranges::begin(__r2), ranges::end(__r2),
- std::move(__pred),
- std::move(__proj1), std::move(__proj2));
- }
-
- template<typename _Iter, typename _Out>
- struct copy_result
- {
- [[no_unique_address]] _Iter in;
- [[no_unique_address]] _Out out;
-
- template<typename _Iter2, typename _Out2>
- requires convertible_to<const _Iter&, _Iter2>
- && convertible_to<const _Out&, _Out2>
- operator copy_result<_Iter2, _Out2>() const &
- { return {in, out}; }
-
- template<typename _Iter2, typename _Out2>
- requires convertible_to<_Iter, _Iter2>
- && convertible_to<_Out, _Out2>
- operator copy_result<_Iter2, _Out2>() &&
- { return {std::move(in), std::move(out)}; }
- };
-
- template<typename _Iter, typename _Out>
- using move_result = copy_result<_Iter, _Out>;
-
- template<typename _Iter1, typename _Iter2>
- using move_backward_result = copy_result<_Iter1, _Iter2>;
-
- template<typename _Iter1, typename _Iter2>
- using copy_backward_result = copy_result<_Iter1, _Iter2>;
-
- template<bool _IsMove,
- bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
- bidirectional_iterator _Out>
- requires (_IsMove
- ? indirectly_movable<_Iter, _Out>
- : indirectly_copyable<_Iter, _Out>)
- constexpr conditional_t<_IsMove,
- move_backward_result<_Iter, _Out>,
- copy_backward_result<_Iter, _Out>>
- __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);
-
- template<bool _IsMove,
- input_iterator _Iter, sentinel_for<_Iter> _Sent,
- weakly_incrementable _Out>
- requires (_IsMove
- ? indirectly_movable<_Iter, _Out>
- : indirectly_copyable<_Iter, _Out>)
- constexpr conditional_t<_IsMove,
- move_result<_Iter, _Out>,
- copy_result<_Iter, _Out>>
- __copy_or_move(_Iter __first, _Sent __last, _Out __result)
- {
- // TODO: implement more specializations to be at least on par with
- // std::copy/std::move.
- constexpr bool __normal_iterator_p
- = (__detail::__is_normal_iterator<_Iter>
- || __detail::__is_normal_iterator<_Out>);
- constexpr bool __reverse_p
- = (__detail::__is_reverse_iterator<_Iter>
- && __detail::__is_reverse_iterator<_Out>);
- constexpr bool __move_iterator_p = __detail::__is_move_iterator<_Iter>;
- if constexpr (__move_iterator_p)
- {
- auto [__in, __out]
- = ranges::__copy_or_move<true>(std::move(__first).base(),
- std::move(__last).base(),
- std::move(__result));
- return {move_iterator{std::move(__in)}, std::move(__out)};
- }
- else if constexpr (__reverse_p)
- {
- auto [__in,__out]
- = ranges::__copy_or_move_backward<_IsMove>(__last.base(),
- __first.base(),
- __result.base());
- return {reverse_iterator{std::move(__in)},
- reverse_iterator{std::move(__out)}};
- }
- else if constexpr (__normal_iterator_p)
- {
- auto [__in,__out]
- = ranges::__copy_or_move<_IsMove>(std::__niter_base(__first),
- std::__niter_base(__last),
- std::__niter_base(__result));
- return {std::__niter_wrap(__first, std::move(__in)),
- std::__niter_wrap(__result, std::move(__out))};
- }
- else if constexpr (sized_sentinel_for<_Sent, _Iter>)
- {
- using _ValueTypeI = iter_value_t<_Iter>;
- using _ValueTypeO = iter_value_t<_Out>;
- constexpr bool __use_memmove
- = (is_trivially_copyable_v<_ValueTypeI>
- && is_same_v<_ValueTypeI, _ValueTypeO>
- && is_pointer_v<_Iter>
- && is_pointer_v<_Out>);
-
- if constexpr (__use_memmove)
- {
- static_assert(_IsMove
- ? is_move_assignable_v<_ValueTypeI>
- : is_copy_assignable_v<_ValueTypeI>);
- auto __num = __last - __first;
- if (__num)
- std::__memmove<_IsMove>(__result, __first, __num);
- return {__first + __num, __result + __num};
- }
- else
- {
- for (auto __n = __last - __first; __n > 0; --__n)
- {
- if constexpr (_IsMove)
- *__result = std::move(*__first);
- else
- *__result = *__first;
- ++__first;
- ++__result;
- }
- return {std::move(__first), std::move(__result)};
- }
- }
- else
- {
- while (__first != __last)
- {
- if constexpr (_IsMove)
- *__result = std::move(*__first);
- else
- *__result = *__first;
- ++__first;
- ++__result;
- }
- return {std::move(__first), std::move(__result)};
- }
- }
-
- template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
- weakly_incrementable _Out>
- requires indirectly_copyable<_Iter, _Out>
- constexpr copy_result<_Iter, _Out>
- copy(_Iter __first, _Sent __last, _Out __result)
- {
- return ranges::__copy_or_move<false>(std::move(__first),
- std::move(__last),
- std::move(__result));
- }
-
- template<input_range _Range, weakly_incrementable _Out>
- requires indirectly_copyable<iterator_t<_Range>, _Out>
- constexpr copy_result<safe_iterator_t<_Range>, _Out>
- copy(_Range&& __r, _Out __result)
- {
- return ranges::copy(ranges::begin(__r), ranges::end(__r),
- std::move(__result));
- }
-
- template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
- weakly_incrementable _Out>
- requires indirectly_movable<_Iter, _Out>
- constexpr move_result<_Iter, _Out>
- move(_Iter __first, _Sent __last, _Out __result)
- {
- return ranges::__copy_or_move<true>(std::move(__first),
- std::move(__last),
- std::move(__result));
- }
-
- template<input_range _Range, weakly_incrementable _Out>
- requires indirectly_movable<iterator_t<_Range>, _Out>
- constexpr move_result<safe_iterator_t<_Range>, _Out>
- move(_Range&& __r, _Out __result)
- {
- return ranges::move(ranges::begin(__r), ranges::end(__r),
- std::move(__result));
- }
-
- template<bool _IsMove,
- bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
- bidirectional_iterator _Out>
- requires (_IsMove
- ? indirectly_movable<_Iter, _Out>
- : indirectly_copyable<_Iter, _Out>)
- constexpr conditional_t<_IsMove,
- move_backward_result<_Iter, _Out>,
- copy_backward_result<_Iter, _Out>>
- __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
- {
- // TODO: implement more specializations to be at least on par with
- // std::copy_backward/std::move_backward.
- constexpr bool __normal_iterator_p
- = (__detail::__is_normal_iterator<_Iter>
- || __detail::__is_normal_iterator<_Out>);
- constexpr bool __reverse_p
- = (__detail::__is_reverse_iterator<_Iter>
- && __detail::__is_reverse_iterator<_Out>);
- if constexpr (__reverse_p)
- {
- auto [__in,__out]
- = ranges::__copy_or_move<_IsMove>(__last.base(),
- __first.base(),
- __result.base());
- return {reverse_iterator{std::move(__in)},
- reverse_iterator{std::move(__out)}};
- }
- else if constexpr (__normal_iterator_p)
- {
- auto [__in,__out]
- = ranges::__copy_or_move_backward<_IsMove>
- (std::__niter_base(__first),
- std::__niter_base(__last),
- std::__niter_base(__result));
- return {std::__niter_wrap(__first, std::move(__in)),
- std::__niter_wrap(__result, std::move(__out))};
- }
- else if constexpr (sized_sentinel_for<_Sent, _Iter>)
- {
- using _ValueTypeI = iter_value_t<_Iter>;
- using _ValueTypeO = iter_value_t<_Out>;
- constexpr bool __use_memmove
- = (is_trivially_copyable_v<_ValueTypeI>
- && is_same_v<_ValueTypeI, _ValueTypeO>
- && is_pointer_v<_Iter>
- && is_pointer_v<_Out>);
- if constexpr (__use_memmove)
- {
- static_assert(_IsMove
- ? is_move_assignable_v<_ValueTypeI>
- : is_copy_assignable_v<_ValueTypeI>);
- auto __num = __last - __first;
- if (__num)
- std::__memmove<_IsMove>(__result - __num, __first, __num);
- return {__first + __num, __result - __num};
- }
- else
- {
- auto __lasti = ranges::next(__first, __last);
- auto __tail = __lasti;
-
- for (auto __n = __last - __first; __n > 0; --__n)
- {
- --__tail;
- --__result;
- if constexpr (_IsMove)
- *__result = std::move(*__tail);
- else
- *__result = *__tail;
- }
- return {std::move(__lasti), std::move(__result)};
- }
- }
- else
- {
- auto __lasti = ranges::next(__first, __last);
- auto __tail = __lasti;
-
- while (__first != __tail)
- {
- --__tail;
- --__result;
- if constexpr (_IsMove)
- *__result = std::move(*__tail);
- else
- *__result = *__tail;
- }
- return {std::move(__lasti), std::move(__result)};
- }
- }
-
- template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
- bidirectional_iterator _Iter2>
- requires indirectly_copyable<_Iter1, _Iter2>
- constexpr copy_backward_result<_Iter1, _Iter2>
- copy_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result)
- {
- return ranges::__copy_or_move_backward<false>(std::move(__first),
- std::move(__last),
- std::move(__result));
- }
-
- template<bidirectional_range _Range, bidirectional_iterator _Iter>
- requires indirectly_copyable<iterator_t<_Range>, _Iter>
- constexpr copy_backward_result<safe_iterator_t<_Range>, _Iter>
- copy_backward(_Range&& __r, _Iter __result)
- {
- return ranges::copy_backward(ranges::begin(__r), ranges::end(__r),
- std::move(__result));
- }
-
- template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
- bidirectional_iterator _Iter2>
- requires indirectly_movable<_Iter1, _Iter2>
- constexpr move_backward_result<_Iter1, _Iter2>
- move_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result)
- {
- return ranges::__copy_or_move_backward<true>(std::move(__first),
- std::move(__last),
- std::move(__result));
- }
-
- template<bidirectional_range _Range, bidirectional_iterator _Iter>
- requires indirectly_movable<iterator_t<_Range>, _Iter>
- constexpr move_backward_result<safe_iterator_t<_Range>, _Iter>
- move_backward(_Range&& __r, _Iter __result)
- {
- return ranges::move_backward(ranges::begin(__r), ranges::end(__r),
- std::move(__result));
- }
-
- template<typename _Iter, typename _Out>
- using copy_n_result = copy_result<_Iter, _Out>;
-
- template<input_iterator _Iter, weakly_incrementable _Out>
- requires indirectly_copyable<_Iter, _Out>
- constexpr copy_n_result<_Iter, _Out>
- copy_n(_Iter __first, iter_difference_t<_Iter> __n, _Out __result)
- {
- if constexpr (random_access_iterator<_Iter>)
- return ranges::copy(__first, __first + __n, std::move(__result));
- else
- {
- for (; __n > 0; --__n, (void)++__result, (void)++__first)
- *__result = *__first;
- return {std::move(__first), std::move(__result)};
- }
- }
-
template<typename _Iter, typename _Out>
using copy_if_result = copy_result<_Iter, _Out>;
@@ -1434,70 +992,6 @@ namespace ranges
__new_value, std::move(__proj));
}
- template<typename _Tp, output_iterator<const _Tp&> _Out>
- constexpr _Out
- fill_n(_Out __first, iter_difference_t<_Out> __n, const _Tp& __value)
- {
- // TODO: implement more specializations to be at least on par with
- // std::fill_n
- if (__n <= 0)
- return __first;
-
- // TODO: is __is_byte the best condition?
- if constexpr (is_pointer_v<_Out> && __is_byte<_Tp>::__value)
- {
- __builtin_memset(__first, static_cast<unsigned char>(__value), __n);
- return __first + __n;
- }
- else if constexpr (is_scalar_v<_Tp>)
- {
- const auto __tmp = __value;
- for (; __n > 0; --__n, (void)++__first)
- *__first = __tmp;
- return __first;
- }
- else
- {
- for (; __n > 0; --__n, (void)++__first)
- *__first = __value;
- return __first;
- }
- }
-
- template<typename _Tp,
- output_iterator<const _Tp&> _Out, sentinel_for<_Out> _Sent>
- constexpr _Out
- fill(_Out __first, _Sent __last, const _Tp& __value)
- {
- // TODO: implement more specializations to be at least on par with
- // std::fill
- if constexpr (sized_sentinel_for<_Sent, _Out>)
- {
- const auto __len = __last - __first;
- return ranges::fill_n(__first, __len, __value);
- }
- else if constexpr (is_scalar_v<_Tp>)
- {
- const auto __tmp = __value;
- for (; __first != __last; ++__first)
- *__first = __tmp;
- return __first;
- }
- else
- {
- for (; __first != __last; ++__first)
- *__first = __value;
- return __first;
- }
- }
-
- template<typename _Tp, output_range<const _Tp&> _Range>
- constexpr safe_iterator_t<_Range>
- fill(_Range&& __r, const _Tp& __value)
- {
- return ranges::fill(ranges::begin(__r), ranges::end(__r), __value);
- }
-
template<input_or_output_iterator _Out, copy_constructible _Fp>
requires invocable<_Fp&>
&& indirectly_writable<_Out, invoke_result_t<_Fp&>>
diff --git a/libstdc++-v3/include/bits/ranges_algobase.h b/libstdc++-v3/include/bits/ranges_algobase.h
new file mode 100644
index 00000000000..f63c032cf0b
--- /dev/null
+++ b/libstdc++-v3/include/bits/ranges_algobase.h
@@ -0,0 +1,556 @@
+// Core algorithmic facilities -*- C++ -*-
+
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/ranges_algobase.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{algorithm}
+ */
+
+#ifndef _RANGES_ALGOBASE_H
+#define _RANGES_ALGOBASE_H 1
+
+#if __cplusplus > 201703L
+
+#include <cmath>
+#include <compare>
+#include <iterator>
+// #include <bits/range_concepts.h>
+#include <ranges>
+#include <bits/invoke.h>
+#include <bits/cpp_type_traits.h> // __is_byte
+
+#if __cpp_lib_concepts
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace ranges
+{
+ namespace __detail
+ {
+ template<typename _Tp>
+ constexpr inline bool __is_normal_iterator = false;
+
+ template<typename _Iterator, typename _Container>
+ constexpr inline bool
+ __is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator,
+ _Container>> = true;
+
+ template<typename _Tp>
+ constexpr inline bool __is_reverse_iterator = false;
+
+ template<typename _Iterator>
+ constexpr inline bool
+ __is_reverse_iterator<reverse_iterator<_Iterator>> = true;
+
+ template<typename _Tp>
+ constexpr inline bool __is_move_iterator = false;
+
+ template<typename _Iterator>
+ constexpr inline bool
+ __is_move_iterator<move_iterator<_Iterator>> = true;
+ } // namespace __detail
+
+ template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
+ input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
+ typename _Pred, typename _Proj1, typename _Proj2>
+ requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
+ constexpr bool
+ __equal(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
+ _Pred __pred, _Proj1 __proj1, _Proj2 __proj2)
+ {
+ // TODO: implement more specializations to at least have parity with
+ // std::equal.
+ constexpr bool __sized_iters
+ = (sized_sentinel_for<_Sent1, _Iter1>
+ && sized_sentinel_for<_Sent2, _Iter2>);
+ if constexpr (__sized_iters)
+ {
+ auto __d1 = ranges::distance(__first1, __last1);
+ auto __d2 = ranges::distance(__first2, __last2);
+ if (__d1 != __d2)
+ return false;
+
+ using _ValueType1 = iter_value_t<_Iter1>;
+ using _ValueType2 = iter_value_t<_Iter2>;
+ constexpr bool __use_memcmp
+ = ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
+ && is_same_v<_ValueType1, _ValueType2>
+ && is_pointer_v<_Iter1>
+ && is_pointer_v<_Iter2>
+ && is_same_v<_Pred, ranges::equal_to>
+ && is_same_v<_Proj1, identity>
+ && is_same_v<_Proj2, identity>);
+ if constexpr (__use_memcmp)
+ {
+ if (const size_t __len = (__last1 - __first1))
+ return !std::__memcmp(__first1, __first2, __len);
+ return true;
+ }
+ else
+ {
+ for (; __first1 != __last1; ++__first1, (void)++__first2)
+ if (!(bool)std::__invoke(__pred,
+ std::__invoke(__proj1, *__first1),
+ std::__invoke(__proj2, *__first2)))
+ return false;
+ return true;
+ }
+ }
+ else
+ {
+ for (; __first1 != __last1 && __first2 != __last2;
+ ++__first1, (void)++__first2)
+ if (!(bool)std::__invoke(__pred,
+ std::__invoke(__proj1, *__first1),
+ std::__invoke(__proj2, *__first2)))
+ return false;
+ return __first1 == __last1 && __first2 == __last2;
+ }
+ }
+
+ template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
+ input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
+ typename _Pred = ranges::equal_to,
+ typename _Proj1 = identity, typename _Proj2 = identity>
+ requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
+ constexpr bool
+ equal(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
+ _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
+ {
+ return ranges::__equal(std::__niter_base(std::move(__first1)),
+ std::__niter_base(std::move(__last1)),
+ std::__niter_base(std::move(__first2)),
+ std::__niter_base(std::move(__last2)),
+ std::move(__pred),
+ std::move(__proj1), std::move(__proj2));
+ }
+
+ template<input_range _Range1, input_range _Range2,
+ typename _Pred = ranges::equal_to,
+ typename _Proj1 = identity, typename _Proj2 = identity>
+ requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
+ _Pred, _Proj1, _Proj2>
+ constexpr bool
+ equal(_Range1&& __r1, _Range2&& __r2,
+ _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
+ {
+ return ranges::equal(ranges::begin(__r1), ranges::end(__r1),
+ ranges::begin(__r2), ranges::end(__r2),
+ std::move(__pred),
+ std::move(__proj1), std::move(__proj2));
+ }
+
+ template<typename _Iter, typename _Out>
+ struct copy_result
+ {
+ [[no_unique_address]] _Iter in;
+ [[no_unique_address]] _Out out;
+
+ template<typename _Iter2, typename _Out2>
+ requires convertible_to<const _Iter&, _Iter2>
+ && convertible_to<const _Out&, _Out2>
+ operator copy_result<_Iter2, _Out2>() const &
+ { return {in, out}; }
+
+ template<typename _Iter2, typename _Out2>
+ requires convertible_to<_Iter, _Iter2>
+ && convertible_to<_Out, _Out2>
+ operator copy_result<_Iter2, _Out2>() &&
+ { return {std::move(in), std::move(out)}; }
+ };
+
+ template<typename _Iter, typename _Out>
+ using move_result = copy_result<_Iter, _Out>;
+
+ template<typename _Iter1, typename _Iter2>
+ using move_backward_result = copy_result<_Iter1, _Iter2>;
+
+ template<typename _Iter1, typename _Iter2>
+ using copy_backward_result = copy_result<_Iter1, _Iter2>;
+
+ template<bool _IsMove,
+ bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
+ bidirectional_iterator _Out>
+ requires (_IsMove
+ ? indirectly_movable<_Iter, _Out>
+ : indirectly_copyable<_Iter, _Out>)
+ constexpr conditional_t<_IsMove,
+ move_backward_result<_Iter, _Out>,
+ copy_backward_result<_Iter, _Out>>
+ __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);
+
+ template<bool _IsMove,
+ input_iterator _Iter, sentinel_for<_Iter> _Sent,
+ weakly_incrementable _Out>
+ requires (_IsMove
+ ? indirectly_movable<_Iter, _Out>
+ : indirectly_copyable<_Iter, _Out>)
+ constexpr conditional_t<_IsMove,
+ move_result<_Iter, _Out>,
+ copy_result<_Iter, _Out>>
+ __copy_or_move(_Iter __first, _Sent __last, _Out __result)
+ {
+ // TODO: implement more specializations to be at least on par with
+ // std::copy/std::move.
+ constexpr bool __normal_iterator_p
+ = (__detail::__is_normal_iterator<_Iter>
+ || __detail::__is_normal_iterator<_Out>);
+ constexpr bool __reverse_p
+ = (__detail::__is_reverse_iterator<_Iter>
+ && __detail::__is_reverse_iterator<_Out>);
+ constexpr bool __move_iterator_p = __detail::__is_move_iterator<_Iter>;
+ if constexpr (__move_iterator_p)
+ {
+ auto [__in, __out]
+ = ranges::__copy_or_move<true>(std::move(__first).base(),
+ std::move(__last).base(),
+ std::move(__result));
+ return {move_iterator{std::move(__in)}, std::move(__out)};
+ }
+ else if constexpr (__reverse_p)
+ {
+ auto [__in,__out]
+ = ranges::__copy_or_move_backward<_IsMove>(__last.base(),
+ __first.base(),
+ __result.base());
+ return {reverse_iterator{std::move(__in)},
+ reverse_iterator{std::move(__out)}};
+ }
+ else if constexpr (__normal_iterator_p)
+ {
+ auto [__in,__out]
+ = ranges::__copy_or_move<_IsMove>(std::__niter_base(__first),
+ std::__niter_base(__last),
+ std::__niter_base(__result));
+ return {std::__niter_wrap(__first, std::move(__in)),
+ std::__niter_wrap(__result, std::move(__out))};
+ }
+ else if constexpr (sized_sentinel_for<_Sent, _Iter>)
+ {
+ using _ValueTypeI = iter_value_t<_Iter>;
+ using _ValueTypeO = iter_value_t<_Out>;
+ constexpr bool __use_memmove
+ = (is_trivially_copyable_v<_ValueTypeI>
+ && is_same_v<_ValueTypeI, _ValueTypeO>
+ && is_pointer_v<_Iter>
+ && is_pointer_v<_Out>);
+
+ if constexpr (__use_memmove)
+ {
+ static_assert(_IsMove
+ ? is_move_assignable_v<_ValueTypeI>
+ : is_copy_assignable_v<_ValueTypeI>);
+ auto __num = __last - __first;
+ if (__num)
+ std::__memmove<_IsMove>(__result, __first, __num);
+ return {__first + __num, __result + __num};
+ }
+ else
+ {
+ for (auto __n = __last - __first; __n > 0; --__n)
+ {
+ if constexpr (_IsMove)
+ *__result = std::move(*__first);
+ else
+ *__result = *__first;
+ ++__first;
+ ++__result;
+ }
+ return {std::move(__first), std::move(__result)};
+ }
+ }
+ else
+ {
+ while (__first != __last)
+ {
+ if constexpr (_IsMove)
+ *__result = std::move(*__first);
+ else
+ *__result = *__first;
+ ++__first;
+ ++__result;
+ }
+ return {std::move(__first), std::move(__result)};
+ }
+ }
+
+ template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
+ weakly_incrementable _Out>
+ requires indirectly_copyable<_Iter, _Out>
+ constexpr copy_result<_Iter, _Out>
+ copy(_Iter __first, _Sent __last, _Out __result)
+ {
+ return ranges::__copy_or_move<false>(std::move(__first),
+ std::move(__last),
+ std::move(__result));
+ }
+
+ template<input_range _Range, weakly_incrementable _Out>
+ requires indirectly_copyable<iterator_t<_Range>, _Out>
+ constexpr copy_result<safe_iterator_t<_Range>, _Out>
+ copy(_Range&& __r, _Out __result)
+ {
+ return ranges::copy(ranges::begin(__r), ranges::end(__r),
+ std::move(__result));
+ }
+
+ template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
+ weakly_incrementable _Out>
+ requires indirectly_movable<_Iter, _Out>
+ constexpr move_result<_Iter, _Out>
+ move(_Iter __first, _Sent __last, _Out __result)
+ {
+ return ranges::__copy_or_move<true>(std::move(__first),
+ std::move(__last),
+ std::move(__result));
+ }
+
+ template<input_range _Range, weakly_incrementable _Out>
+ requires indirectly_movable<iterator_t<_Range>, _Out>
+ constexpr move_result<safe_iterator_t<_Range>, _Out>
+ move(_Range&& __r, _Out __result)
+ {
+ return ranges::move(ranges::begin(__r), ranges::end(__r),
+ std::move(__result));
+ }
+
+ template<bool _IsMove,
+ bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
+ bidirectional_iterator _Out>
+ requires (_IsMove
+ ? indirectly_movable<_Iter, _Out>
+ : indirectly_copyable<_Iter, _Out>)
+ constexpr conditional_t<_IsMove,
+ move_backward_result<_Iter, _Out>,
+ copy_backward_result<_Iter, _Out>>
+ __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
+ {
+ // TODO: implement more specializations to be at least on par with
+ // std::copy_backward/std::move_backward.
+ constexpr bool __normal_iterator_p
+ = (__detail::__is_normal_iterator<_Iter>
+ || __detail::__is_normal_iterator<_Out>);
+ constexpr bool __reverse_p
+ = (__detail::__is_reverse_iterator<_Iter>
+ && __detail::__is_reverse_iterator<_Out>);
+ if constexpr (__reverse_p)
+ {
+ auto [__in,__out]
+ = ranges::__copy_or_move<_IsMove>(__last.base(),
+ __first.base(),
+ __result.base());
+ return {reverse_iterator{std::move(__in)},
+ reverse_iterator{std::move(__out)}};
+ }
+ else if constexpr (__normal_iterator_p)
+ {
+ auto [__in,__out]
+ = ranges::__copy_or_move_backward<_IsMove>
+ (std::__niter_base(__first),
+ std::__niter_base(__last),
+ std::__niter_base(__result));
+ return {std::__niter_wrap(__first, std::move(__in)),
+ std::__niter_wrap(__result, std::move(__out))};
+ }
+ else if constexpr (sized_sentinel_for<_Sent, _Iter>)
+ {
+ using _ValueTypeI = iter_value_t<_Iter>;
+ using _ValueTypeO = iter_value_t<_Out>;
+ constexpr bool __use_memmove
+ = (is_trivially_copyable_v<_ValueTypeI>
+ && is_same_v<_ValueTypeI, _ValueTypeO>
+ && is_pointer_v<_Iter>
+ && is_pointer_v<_Out>);
+ if constexpr (__use_memmove)
+ {
+ static_assert(_IsMove
+ ? is_move_assignable_v<_ValueTypeI>
+ : is_copy_assignable_v<_ValueTypeI>);
+ auto __num = __last - __first;
+ if (__num)
+ std::__memmove<_IsMove>(__result - __num, __first, __num);
+ return {__first + __num, __result - __num};
+ }
+ else
+ {
+ auto __lasti = ranges::next(__first, __last);
+ auto __tail = __lasti;
+
+ for (auto __n = __last - __first; __n > 0; --__n)
+ {
+ --__tail;
+ --__result;
+ if constexpr (_IsMove)
+ *__result = std::move(*__tail);
+ else
+ *__result = *__tail;
+ }
+ return {std::move(__lasti), std::move(__result)};
+ }
+ }
+ else
+ {
+ auto __lasti = ranges::next(__first, __last);
+ auto __tail = __lasti;
+
+ while (__first != __tail)
+ {
+ --__tail;
+ --__result;
+ if constexpr (_IsMove)
+ *__result = std::move(*__tail);
+ else
+ *__result = *__tail;
+ }
+ return {std::move(__lasti), std::move(__result)};
+ }
+ }
+
+ template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
+ bidirectional_iterator _Iter2>
+ requires indirectly_copyable<_Iter1, _Iter2>
+ constexpr copy_backward_result<_Iter1, _Iter2>
+ copy_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result)
+ {
+ return ranges::__copy_or_move_backward<false>(std::move(__first),
+ std::move(__last),
+ std::move(__result));
+ }
+
+ template<bidirectional_range _Range, bidirectional_iterator _Iter>
+ requires indirectly_copyable<iterator_t<_Range>, _Iter>
+ constexpr copy_backward_result<safe_iterator_t<_Range>, _Iter>
+ copy_backward(_Range&& __r, _Iter __result)
+ {
+ return ranges::copy_backward(ranges::begin(__r), ranges::end(__r),
+ std::move(__result));
+ }
+
+ template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
+ bidirectional_iterator _Iter2>
+ requires indirectly_movable<_Iter1, _Iter2>
+ constexpr move_backward_result<_Iter1, _Iter2>
+ move_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result)
+ {
+ return ranges::__copy_or_move_backward<true>(std::move(__first),
+ std::move(__last),
+ std::move(__result));
+ }
+
+ template<bidirectional_range _Range, bidirectional_iterator _Iter>
+ requires indirectly_movable<iterator_t<_Range>, _Iter>
+ constexpr move_backward_result<safe_iterator_t<_Range>, _Iter>
+ move_backward(_Range&& __r, _Iter __result)
+ {
+ return ranges::move_backward(ranges::begin(__r), ranges::end(__r),
+ std::move(__result));
+ }
+
+ template<typename _Iter, typename _Out>
+ using copy_n_result = copy_result<_Iter, _Out>;
+
+ template<input_iterator _Iter, weakly_incrementable _Out>
+ requires indirectly_copyable<_Iter, _Out>
+ constexpr copy_n_result<_Iter, _Out>
+ copy_n(_Iter __first, iter_difference_t<_Iter> __n, _Out __result)
+ {
+ if constexpr (random_access_iterator<_Iter>)
+ return ranges::copy(__first, __first + __n, std::move(__result));
+ else
+ {
+ for (; __n > 0; --__n, (void)++__result, (void)++__first)
+ *__result = *__first;
+ return {std::move(__first), std::move(__result)};
+ }
+ }
+
+ template<typename _Tp, output_iterator<const _Tp&> _Out>
+ constexpr _Out
+ fill_n(_Out __first, iter_difference_t<_Out> __n, const _Tp& __value)
+ {
+ // TODO: implement more specializations to be at least on par with
+ // std::fill_n
+ if (__n <= 0)
+ return __first;
+
+ // TODO: is __is_byte the best condition?
+ if constexpr (is_pointer_v<_Out> && __is_byte<_Tp>::__value)
+ {
+ __builtin_memset(__first, static_cast<unsigned char>(__value), __n);
+ return __first + __n;
+ }
+ else if constexpr (is_scalar_v<_Tp>)
+ {
+ const auto __tmp = __value;
+ for (; __n > 0; --__n, (void)++__first)
+ *__first = __tmp;
+ return __first;
+ }
+ else
+ {
+ for (; __n > 0; --__n, (void)++__first)
+ *__first = __value;
+ return __first;
+ }
+ }
+
+ template<typename _Tp,
+ output_iterator<const _Tp&> _Out, sentinel_for<_Out> _Sent>
+ constexpr _Out
+ fill(_Out __first, _Sent __last, const _Tp& __value)
+ {
+ // TODO: implement more specializations to be at least on par with
+ // std::fill
+ if constexpr (sized_sentinel_for<_Sent, _Out>)
+ {
+ const auto __len = __last - __first;
+ return ranges::fill_n(__first, __len, __value);
+ }
+ else if constexpr (is_scalar_v<_Tp>)
+ {
+ const auto __tmp = __value;
+ for (; __first != __last; ++__first)
+ *__first = __tmp;
+ return __first;
+ }
+ else
+ {
+ for (; __first != __last; ++__first)
+ *__first = __value;
+ return __first;
+ }
+ }
+
+ template<typename _Tp, output_range<const _Tp&> _Range>
+ constexpr safe_iterator_t<_Range>
+ fill(_Range&& __r, const _Tp& __value)
+ {
+ return ranges::fill(ranges::begin(__r), ranges::end(__r), __value);
+ }
+}
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+#endif // concepts
+#endif // C++20
+#endif // _RANGES_ALGOBASE_H
--
2.25.0.191.gde93cc14ab
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH 2/2] libstdc++: Implement ranges [specialized.algorithms]
2020-02-12 20:42 [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h> Patrick Palka
@ 2020-02-12 20:42 ` Patrick Palka
2020-02-13 16:12 ` Jonathan Wakely
2020-02-13 12:20 ` [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h> Jonathan Wakely
1 sibling, 1 reply; 5+ messages in thread
From: Patrick Palka @ 2020-02-12 20:42 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, jwakely, Patrick Palka
This implements all the ranges members defined in [specialized.algorithms]:
ranges::uninitialized_default_construct
ranges::uninitialized_value_construct
ranges::uninitialized_copy
ranges::uninitialized_copy_n
ranges::uninitialized_move
ranges::uninitialized_move_n
ranges::uninitialized_fill
ranges::uninitialized_fill_n
ranges::construct_at
ranges::destroy_at
ranges::destroy
It also implements (hopefully correctly) the "obvious" optimizations for these
algos, namely that if the output range has a trivial value type and if the
appropriate operation won't throw then we can dispatch to the standard ranges
version of the algorithm which will then potentially enable further
optimizations.
libstdc++-v3/ChangeLog:
* include/Makefile.am: Add <bits/ranges_uninitialized.h>.
* include/Makefile.in: Regenerate.
* include/bits/ranges_uninitialized.h: New header.
* include/std/memory: Include it.
* testsuite/20_util/specialized_algorithms/destroy/constrained.cc: New
test.
* .../uninitialized_copy/constrained.cc: New test.
* .../uninitialized_default_construct/constrained.cc: New test.
* .../uninitialized_fill/constrained.cc: New test.
* .../uninitialized_move/constrained.cc: New test.
* .../uninitialized_value_construct/constrained.cc: New test.
---
libstdc++-v3/include/Makefile.am | 1 +
libstdc++-v3/include/Makefile.in | 1 +
.../include/bits/ranges_uninitialized.h | 491 ++++++++++++++++++
libstdc++-v3/include/std/memory | 1 +
.../destroy/constrained.cc | 76 +++
.../uninitialized_copy/constrained.cc | 166 ++++++
.../constrained.cc | 147 ++++++
.../uninitialized_fill/constrained.cc | 137 +++++
.../uninitialized_move/constrained.cc | 176 +++++++
.../constrained.cc | 140 +++++
10 files changed, 1336 insertions(+)
create mode 100644 libstdc++-v3/include/bits/ranges_uninitialized.h
create mode 100644 libstdc++-v3/testsuite/20_util/specialized_algorithms/destroy/constrained.cc
create mode 100644 libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc
create mode 100644 libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_default_construct/constrained.cc
create mode 100644 libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_fill/constrained.cc
create mode 100644 libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc
create mode 100644 libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_value_construct/constrained.cc
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 614222db400..e131ce04f8c 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -159,6 +159,7 @@ bits_headers = \
${bits_srcdir}/range_cmp.h \
${bits_srcdir}/ranges_algobase.h \
${bits_srcdir}/ranges_algo.h \
+ ${bits_srcdir}/ranges_uninitialized.h \
${bits_srcdir}/refwrap.h \
${bits_srcdir}/regex.h \
${bits_srcdir}/regex.tcc \
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index 7ee6a1e3f61..ae20f6b1d21 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -504,6 +504,7 @@ bits_headers = \
${bits_srcdir}/range_cmp.h \
${bits_srcdir}/ranges_algobase.h \
${bits_srcdir}/ranges_algo.h \
+ ${bits_srcdir}/ranges_uninitialized.h \
${bits_srcdir}/refwrap.h \
${bits_srcdir}/regex.h \
${bits_srcdir}/regex.tcc \
diff --git a/libstdc++-v3/include/bits/ranges_uninitialized.h b/libstdc++-v3/include/bits/ranges_uninitialized.h
new file mode 100644
index 00000000000..252295faed7
--- /dev/null
+++ b/libstdc++-v3/include/bits/ranges_uninitialized.h
@@ -0,0 +1,491 @@
+// Raw memory manipulators -*- C++ -*-
+
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/ranges_uninitialized.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _RANGES_UNINITIALIZED_H
+#define _RANGES_UNINITIALIZED_H 1
+
+#if __cplusplus > 201703L
+#if __cpp_lib_concepts
+
+#include <bits/ranges_algobase.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace ranges
+{
+ namespace __detail
+ {
+ template<typename _Tp>
+ constexpr void*
+ __voidify(_Tp& __obj) noexcept
+ {
+ return const_cast<void*>
+ (static_cast<const volatile void*>(std::__addressof(__obj)));
+ }
+
+ template<typename _Iter>
+ concept __nothrow_input_iterator
+ = (input_iterator<_Iter>
+ && is_lvalue_reference_v<iter_reference_t<_Iter>>
+ && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
+ iter_value_t<_Iter>>);
+
+ template<typename _Sent, typename _Iter>
+ concept __nothrow_sentinel = sentinel_for<_Sent, _Iter>;
+
+ template<typename _Range>
+ concept __nothrow_input_range
+ = (range<_Range>
+ && __nothrow_input_iterator<iterator_t<_Range>>
+ && __nothrow_sentinel<sentinel_t<_Range>, iterator_t<_Range>>);
+
+ template<typename _Iter>
+ concept __nothrow_forward_iterator
+ = (__nothrow_input_iterator<_Iter>
+ && forward_iterator<_Iter>
+ && __nothrow_sentinel<_Iter, _Iter>);
+
+ template<typename _Range>
+ concept __nothrow_forward_range
+ = (__nothrow_input_range<_Range>
+ && __nothrow_forward_iterator<iterator_t<_Range>>);
+ } // namespace __detail
+
+ template<__detail::__nothrow_input_iterator _Iter,
+ __detail::__nothrow_sentinel<_Iter> _Sent>
+ requires destructible<iter_value_t<_Iter>>
+ constexpr _Iter
+ destroy(_Iter __first, _Sent __last) noexcept;
+
+ namespace __detail
+ {
+ template<typename _Iter>
+ requires destructible<iter_value_t<_Iter>>
+ struct _DestroyGuard
+ {
+ private:
+ _Iter _M_first;
+ const _Iter* _M_cur;
+
+ public:
+ explicit
+ _DestroyGuard(const _Iter* __iter)
+ : _M_first(*__iter), _M_cur(__iter)
+ { }
+
+ void
+ release() noexcept
+ { _M_cur = nullptr; }
+
+ ~_DestroyGuard()
+ {
+ if (_M_cur != nullptr)
+ ranges::destroy(std::move(_M_first), *_M_cur);
+ }
+ };
+
+ template<typename _Iter>
+ requires destructible<iter_value_t<_Iter>>
+ && is_trivially_destructible_v<iter_value_t<_Iter>>
+ struct _DestroyGuard<_Iter>
+ {
+ explicit
+ _DestroyGuard(const _Iter*)
+ { }
+
+ void
+ release() noexcept
+ { }
+ };
+ } // namespace __detail
+
+ template<__detail::__nothrow_forward_iterator _Iter,
+ __detail::__nothrow_sentinel<_Iter> _Sent>
+ requires default_initializable<iter_value_t<_Iter>>
+ _Iter
+ uninitialized_default_construct(_Iter __first, _Sent __last)
+ {
+ using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
+ if constexpr (is_trivially_default_constructible_v<_ValueType>)
+ return ranges::next(__first, __last);
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__first);
+ for (; __first != __last; ++__first)
+ ::new (__detail::__voidify(*__first)) _ValueType;
+ __guard.release();
+ return __first;
+ }
+ }
+
+ template<__detail::__nothrow_forward_range _Range>
+ requires default_initializable<range_value_t<_Range>>
+ safe_iterator_t<_Range>
+ uninitialized_default_construct(_Range&& __r)
+ {
+ return ranges::uninitialized_default_construct(ranges::begin(__r),
+ ranges::end(__r));
+ }
+
+ template<__detail::__nothrow_forward_iterator _Iter>
+ requires default_initializable<iter_value_t<_Iter>>
+ _Iter
+ uninitialized_default_construct_n(_Iter __first,
+ iter_difference_t<_Iter> __n)
+ {
+ using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
+ if constexpr (is_trivially_default_constructible_v<_ValueType>)
+ return ranges::next(__first, __n);
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__first);
+ for (; __n > 0; ++__first, (void) --__n)
+ ::new (__detail::__voidify(*__first)) _ValueType;
+ __guard.release();
+ return __first;
+ }
+ }
+
+ template<__detail::__nothrow_forward_iterator _Iter,
+ __detail::__nothrow_sentinel<_Iter> _Sent>
+ requires default_initializable<iter_value_t<_Iter>>
+ _Iter
+ uninitialized_value_construct(_Iter __first, _Sent __last)
+ {
+ using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
+ if constexpr (is_trivial_v<_ValueType>
+ && is_copy_assignable_v<_ValueType>)
+ return ranges::fill(__first, __last, _ValueType());
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__first);
+ for (; __first != __last; ++__first)
+ ::new (__detail::__voidify(*__first)) _ValueType();
+ __guard.release();
+ return __first;
+ }
+ }
+
+ template<__detail::__nothrow_forward_range _Range>
+ requires default_initializable<range_value_t<_Range>>
+ safe_iterator_t<_Range>
+ uninitialized_value_construct(_Range&& __r)
+ {
+ return ranges::uninitialized_value_construct(ranges::begin(__r),
+ ranges::end(__r));
+ }
+
+ template<__detail::__nothrow_forward_iterator _Iter>
+ requires default_initializable<iter_value_t<_Iter>>
+ _Iter
+ uninitialized_value_construct_n(_Iter __first, iter_difference_t<_Iter> __n)
+ {
+ using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
+ if constexpr (is_trivial_v<_ValueType>
+ && is_copy_assignable_v<_ValueType>)
+ return ranges::fill_n(__first, __n, _ValueType());
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__first);
+ for (; __n > 0; ++__first, (void) --__n)
+ ::new (__detail::__voidify(*__first)) _ValueType();
+ __guard.release();
+ return __first;
+ }
+ }
+
+ template<typename _Iter, typename _Out>
+ using uninitialized_copy_result = copy_result<_Iter, _Out>;
+
+ template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
+ __detail::__nothrow_forward_iterator _Out,
+ __detail::__nothrow_sentinel<_Out> _OSent>
+ requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>>
+ uninitialized_copy_result<_Iter, _Out>
+ uninitialized_copy(_Iter __ifirst, _ISent __ilast,
+ _Out __ofirst, _OSent __olast)
+ {
+ using _OutType = remove_reference_t<iter_reference_t<_Out>>;
+ if constexpr (sized_sentinel_for<_ISent, _Iter>
+ && sized_sentinel_for<_OSent, _Out>
+ && is_trivial_v<_OutType>
+ && is_nothrow_assignable_v<_OutType,
+ iter_reference_t<_Iter>>)
+ {
+ auto __d1 = ranges::distance(__ifirst, __ilast);
+ auto __d2 = ranges::distance(__ofirst, __olast);
+ return ranges::copy_n(__ifirst, std::min(__d1, __d2), __ofirst);
+ }
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__ofirst);
+ for (; __ifirst != __ilast && __ofirst != __olast;
+ ++__ofirst, (void)++__ifirst)
+ ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
+ __guard.release();
+ return {__ifirst, __ofirst};
+ }
+ }
+
+ template<input_range _IRange, __detail::__nothrow_forward_range _ORange>
+ requires constructible_from<range_value_t<_ORange>,
+ range_reference_t<_IRange>>
+ uninitialized_copy_result<safe_iterator_t<_IRange>,
+ safe_iterator_t<_ORange>>
+ uninitialized_copy(_IRange&& __inr, _ORange&& __outr)
+ {
+ return ranges::uninitialized_copy(ranges::begin(__inr),
+ ranges::end(__inr),
+ ranges::begin(__outr),
+ ranges::end(__outr));
+ }
+
+ template<typename _Iter, typename _Out>
+ using uninitialized_copy_n_result = uninitialized_copy_result<_Iter, _Out>;
+
+ template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
+ __detail::__nothrow_sentinel<_Out> _Sent>
+ requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>>
+ uninitialized_copy_n_result<_Iter, _Out>
+ uninitialized_copy_n(_Iter __ifirst, iter_difference_t<_Iter> __n,
+ _Out __ofirst, _Sent __olast)
+ {
+ using _OutType = remove_reference_t<iter_reference_t<_Out>>;
+ if constexpr (sized_sentinel_for<_Sent, _Out>
+ && is_trivial_v<_OutType>
+ && is_nothrow_assignable_v<_OutType,
+ iter_reference_t<_Iter>>)
+ {
+ auto __d = ranges::distance(__ofirst, __olast);
+ return ranges::copy_n(__ifirst, std::min(__n, __d), __ofirst);
+ }
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__ofirst);
+ for (; __n > 0 && __ofirst != __olast;
+ ++__ofirst, (void)++__ifirst, (void)--__n)
+ ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
+ __guard.release();
+ return {__ifirst, __ofirst};
+ }
+ }
+
+ template<typename _Iter, typename _Out>
+ using uninitialized_move_result = uninitialized_copy_result<_Iter, _Out>;
+
+ template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
+ __detail::__nothrow_forward_iterator _Out,
+ __detail::__nothrow_sentinel<_Out> _OSent>
+ requires constructible_from<iter_value_t<_Out>,
+ iter_rvalue_reference_t<_Iter>>
+ uninitialized_move_result<_Iter, _Out>
+ uninitialized_move(_Iter __ifirst, _ISent __ilast,
+ _Out __ofirst, _OSent __olast)
+ {
+ using _OutType = remove_reference_t<iter_reference_t<_Out>>;
+ if constexpr (sized_sentinel_for<_ISent, _Iter>
+ && sized_sentinel_for<_OSent, _Out>
+ && is_trivial_v<_OutType>
+ && is_nothrow_assignable_v<_OutType,
+ iter_rvalue_reference_t<_Iter>>)
+ {
+ auto __d1 = ranges::distance(__ifirst, __ilast);
+ auto __d2 = ranges::distance(__ofirst, __olast);
+ return ranges::copy_n(std::make_move_iterator(__ifirst),
+ std::min(__d1, __d2), __ofirst);
+ }
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__ofirst);
+ for (; __ifirst != __ilast && __ofirst != __olast;
+ ++__ofirst, (void)++__ifirst)
+ ::new (__detail::__voidify(*__ofirst))
+ _OutType(ranges::iter_move(__ifirst));
+ __guard.release();
+ return {__ifirst, __ofirst};
+ }
+ }
+
+ template<input_range _IRange, __detail::__nothrow_forward_range _ORange>
+ requires constructible_from<range_value_t<_ORange>,
+ range_rvalue_reference_t<_IRange>>
+ uninitialized_move_result<safe_iterator_t<_IRange>,
+ safe_iterator_t<_ORange>>
+ uninitialized_move(_IRange&& __inr, _ORange&& __outr)
+ {
+ return ranges::uninitialized_move(ranges::begin(__inr),
+ ranges::end(__inr),
+ ranges::begin(__outr),
+ ranges::end(__outr));
+ }
+
+ template<typename _Iter, typename _Out>
+ using uninitialized_move_n_result = uninitialized_copy_result<_Iter, _Out>;
+
+ template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
+ __detail::__nothrow_sentinel<_Out> _Sent>
+ requires constructible_from<iter_value_t<_Out>,
+ iter_rvalue_reference_t<_Iter>>
+ uninitialized_move_n_result<_Iter, _Out>
+ uninitialized_move_n(_Iter __ifirst, iter_difference_t<_Iter> __n,
+ _Out __ofirst, _Sent __olast)
+ {
+ using _OutType = remove_reference_t<iter_reference_t<_Out>>;
+ if constexpr (sized_sentinel_for<_Sent, _Out>
+ && is_trivial_v<_OutType>
+ && is_nothrow_assignable_v<_OutType,
+ iter_rvalue_reference_t<_Iter>>)
+ {
+ auto __d = ranges::distance(__ofirst, __olast);
+ return ranges::copy_n(std::make_move_iterator(__ifirst),
+ std::min(__n, __d), __ofirst);
+ }
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__ofirst);
+ for (; __n > 0 && __ofirst != __olast;
+ ++__ofirst, (void)++__ifirst, (void)--__n)
+ ::new (__detail::__voidify(*__ofirst))
+ _OutType(ranges::iter_move(__ifirst));
+ __guard.release();
+ return {__ifirst, __ofirst};
+ }
+ }
+
+ template<__detail::__nothrow_forward_iterator _Iter,
+ __detail::__nothrow_sentinel<_Iter> _Sent, typename _Tp>
+ requires constructible_from<iter_value_t<_Iter>, const _Tp&>
+ _Iter
+ uninitialized_fill(_Iter __first, _Sent __last, const _Tp& __x)
+ {
+ using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
+ if constexpr (is_trivial_v<_ValueType>
+ && is_nothrow_assignable_v<_ValueType, const _Tp&>)
+ return ranges::fill(__first, __last, __x);
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__first);
+ for (; __first != __last; ++__first)
+ ::new (__detail::__voidify(*__first)) _ValueType(__x);
+ __guard.release();
+ return __first;
+ }
+ }
+
+ template<__detail::__nothrow_forward_range _Range, typename _Tp>
+ requires constructible_from<range_value_t<_Range>, const _Tp&>
+ safe_iterator_t<_Range>
+ uninitialized_fill(_Range&& __r, const _Tp& __x)
+ {
+ return ranges::uninitialized_fill(ranges::begin(__r), ranges::end(__r),
+ __x);
+ }
+
+ template<__detail::__nothrow_forward_iterator _Iter, typename _Tp>
+ requires constructible_from<iter_value_t<_Iter>, const _Tp&>
+ _Iter
+ uninitialized_fill_n(_Iter __first, iter_difference_t<_Iter> __n,
+ const _Tp& __x)
+ {
+ using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
+ if constexpr (is_trivial_v<_ValueType>
+ && is_nothrow_assignable_v<_ValueType, const _Tp&>)
+ return ranges::fill_n(__first, __n, __x);
+ else
+ {
+ auto __guard = __detail::_DestroyGuard(&__first);
+ for (; __n > 0; ++__first, (void)--__n)
+ ::new (__detail::__voidify(*__first)) _ValueType(__x);
+ __guard.release();
+ return __first;
+ }
+ }
+
+ template<typename _Tp, typename... _Args>
+ requires requires { ::new (declval<void*>()) _Tp(declval<_Args>()...); }
+ constexpr _Tp*
+ construct_at(_Tp* __location, _Args&&... __args)
+ {
+ return ::new (__detail::__voidify(*__location))
+ _Tp(std::forward<_Args>(__args)...);
+ }
+
+ template<destructible _Tp>
+ constexpr void
+ destroy_at(_Tp* __location) noexcept
+ {
+ if constexpr (is_array_v<_Tp>)
+ ranges::destroy(ranges::begin(*__location), ranges::end(*__location));
+ else
+ __location->~_Tp();
+ }
+
+ template<__detail::__nothrow_input_iterator _Iter,
+ __detail::__nothrow_sentinel<_Iter> _Sent>
+ requires destructible<iter_value_t<_Iter>>
+ constexpr _Iter
+ destroy(_Iter __first, _Sent __last) noexcept
+ {
+ if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
+ return ranges::next(__first, __last);
+ else
+ {
+ for (; __first != __last; ++__first)
+ ranges::destroy_at(addressof(*__first));
+ return __first;
+ }
+ }
+
+ template<__detail::__nothrow_input_range _Range>
+ requires destructible<range_value_t<_Range>>
+ constexpr safe_iterator_t<_Range>
+ destroy(_Range&& __r) noexcept
+ { return ranges::destroy(ranges::begin(__r), ranges::end(__r)); }
+
+ template<__detail::__nothrow_input_iterator _Iter>
+ requires destructible<iter_value_t<_Iter>>
+ constexpr _Iter
+ destroy_n(_Iter __first, iter_difference_t<_Iter> __n) noexcept
+ {
+ if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
+ return ranges::next(__first, __n);
+ else
+ {
+ for (; __n > 0; ++__first, (void)--__n)
+ ranges::destroy_at(addressof(*__first));
+ return __first;
+ }
+ }
+}
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+#endif // concepts
+#endif // C++20
+#endif // _RANGES_UNINITIALIZED_H
diff --git a/libstdc++-v3/include/std/memory b/libstdc++-v3/include/std/memory
index b4caa1167a7..823bd21a5ad 100644
--- a/libstdc++-v3/include/std/memory
+++ b/libstdc++-v3/include/std/memory
@@ -66,6 +66,7 @@
#include <bits/stl_uninitialized.h>
#include <bits/stl_tempbuf.h>
#include <bits/stl_raw_storage_iter.h>
+#include <bits/ranges_uninitialized.h>
#if __cplusplus >= 201103L
# include <exception> // std::exception
diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/destroy/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/destroy/constrained.cc
new file mode 100644
index 00000000000..730625d9a21
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/destroy/constrained.cc
@@ -0,0 +1,76 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <algorithm>
+#include <cstring>
+#include <deque>
+#include <list>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+namespace ranges = std::ranges;
+
+struct X
+{
+ X()
+ { ++count; }
+
+ ~X()
+ { --count; }
+
+ static inline int count = 0;
+};
+
+void
+test01()
+{
+ for (int k = 0; k < 3; k++)
+ {
+ constexpr int size = 1024;
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(X)*size]);
+ std::span<X> rx((X *)buffer.get(), size);
+
+ ranges::uninitialized_default_construct(rx);
+ VERIFY( X::count == size );
+
+ auto i = rx.cbegin();
+ if (k == 0)
+ i = ranges::destroy(rx);
+ else if (k == 1)
+ i = ranges::destroy(rx.begin(), rx.end());
+ else if (k == 2)
+ i = ranges::destroy_n(rx.begin(), size);
+ else
+ __builtin_abort();
+
+ VERIFY( i == rx.cend() );
+ VERIFY( X::count == 0 );
+ }
+}
+
+int
+main()
+{
+ test01();
+}
diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc
new file mode 100644
index 00000000000..948406432cb
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc
@@ -0,0 +1,166 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <algorithm>
+#include <cstring>
+#include <deque>
+#include <list>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+using __gnu_test::test_input_range;
+using __gnu_test::test_forward_range;
+
+namespace ranges = std::ranges;
+
+template<typename T>
+void
+test01(const std::vector<T> &ix)
+{
+ static_assert(std::copy_constructible<T>);
+ static_assert(std::equality_comparable<T>);
+
+ for (int k = 0; k < 7; k++)
+ {
+ int size = ix.size();
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(T)*size]);
+ std::span<T> rx((T *)buffer.get(), size);
+
+ ranges::uninitialized_copy_result res = {ix.cbegin(), rx.cbegin()};
+ if (k == 0)
+ res = ranges::uninitialized_copy(ix.begin(), ix.end(),
+ rx.begin(), rx.end());
+ else if (k == 1)
+ res = ranges::uninitialized_copy(ix, rx);
+ else if (k == 2)
+ res = ranges::uninitialized_copy_n(ix.begin(), size,
+ rx.begin(), rx.end());
+ else if (k == 3)
+ res = ranges::uninitialized_copy(ix.begin(), ix.end(),
+ rx.cbegin(), rx.cend());
+ else if (k == 4)
+ res = ranges::uninitialized_copy(ix, std::as_const(rx));
+ else if (k == 5)
+ res = ranges::uninitialized_copy_n(ix.begin(), size,
+ rx.cbegin(), rx.cend());
+ else if (k == 6)
+ res = ranges::uninitialized_copy_n(ix.begin(), size/2,
+ rx.cbegin(), rx.cend());
+ else if (k == 7)
+ res = ranges::uninitialized_copy_n(ix.begin(), size,
+ rx.cbegin(), rx.cbegin()+size/2);
+ else
+ __builtin_abort();
+
+ if (k == 6 || k == 7)
+ {
+ VERIFY( ranges::distance(ix.cbegin(), res.in) == size/2 );
+ VERIFY( ranges::distance(rx.cbegin(), res.out) == size/2 );
+ VERIFY( ranges::equal(ix.begin(), ix.begin()+size/2,
+ rx.begin(), rx.begin()+size/2) );
+ ranges::destroy(rx.begin(), rx.begin()+size/2);
+ }
+ else
+ {
+ VERIFY( res.in == ix.cend() );
+ VERIFY( res.out == rx.cend() );
+ VERIFY( ranges::equal(ix, rx) );
+ ranges::destroy(rx);
+ }
+ }
+}
+
+struct X
+{
+ static constexpr int limit = 67;
+ static inline int copy_construct_count = 0;
+ static inline int destruct_count = 0;
+
+ struct exception {};
+
+ bool live = false;
+
+ X()
+ { live = true; }
+
+ X& operator=(const X&) = delete;
+
+ X(const X&)
+ {
+ live = true;
+ if (copy_construct_count >= limit)
+ throw exception{};
+ copy_construct_count++;
+ }
+
+ ~X()
+ {
+ VERIFY( live );
+ live = false;
+ destruct_count++;
+ }
+};
+
+template<bool test_sized>
+void
+test02()
+{
+ constexpr int size = 100;
+ X x[size];
+ // FIXME: Should be test_input_range?
+ test_forward_range<X> ix(x);
+
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(X)*size]);
+ test_forward_range<X> rx((X *)buffer.get(), (X *)buffer.get() + size);
+ try
+ {
+ X::copy_construct_count = 0;
+ X::destruct_count = 0;
+ if constexpr (test_sized)
+ ranges::uninitialized_copy_n(ix.begin(), size, rx.begin(), rx.end());
+ else
+ ranges::uninitialized_copy(ix, rx);
+ VERIFY( false && "exception not thrown" );
+ }
+ catch (const X::exception&)
+ {
+ VERIFY( X::copy_construct_count == X::limit );
+ VERIFY( X::destruct_count == X::limit );
+ }
+}
+
+int
+main()
+{
+ test01<char>({1,2,3,4,5});
+ test01<int>({1,2,3,4,5});
+ test01<long long>({1,2,3,4,5});
+ test01<float>({1.1,2.1,3.1,4.1});
+ test01<double>({1.1,2.1,3.1,4.1});
+ test01<std::vector<char>>({{'a','b'}, {'c','d'}, {'e','f'}});
+ test01<std::string>({"the", "quick", "brown", "fox"});
+
+ test02<false>();
+ test02<true>();
+}
diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_default_construct/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_default_construct/constrained.cc
new file mode 100644
index 00000000000..6ef24cc7ea0
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_default_construct/constrained.cc
@@ -0,0 +1,147 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <algorithm>
+#include <cstring>
+#include <deque>
+#include <list>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+using __gnu_test::test_forward_range;
+
+namespace ranges = std::ranges;
+
+template<typename T>
+void
+test01()
+{
+ static_assert(std::default_initializable<T>);
+ static_assert(std::equality_comparable<T>);
+
+ for (int k = 0; k < 6; k++)
+ {
+ constexpr int size = 1024;
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(T)*size]);
+ std::span<T> rx((T *)buffer.get(), size);
+
+ T t;
+ if constexpr (std::is_fundamental_v<T>)
+ {
+ std::memset(&t, 0xCC, sizeof(t));
+ ranges::fill(rx, t);
+ }
+
+ auto i = rx.cbegin();
+ if (k == 0)
+ i = ranges::uninitialized_default_construct(rx.begin(), rx.end());
+ else if (k == 1)
+ i = ranges::uninitialized_default_construct(rx);
+ else if (k == 2)
+ i = ranges::uninitialized_default_construct_n(rx.begin(), 1024);
+ else if constexpr (std::is_fundamental_v<T>)
+ continue;
+ else if (k == 3)
+ i = ranges::uninitialized_default_construct(rx.cbegin(), rx.cend());
+ else if (k == 4)
+ i = ranges::uninitialized_default_construct(std::as_const(rx));
+ else if (k == 5)
+ i = ranges::uninitialized_default_construct_n(rx.cbegin(), 1024);
+ else
+ __builtin_abort();
+
+ VERIFY( i == rx.cend() );
+ VERIFY( ranges::find_if(rx, [&t](const T& v) { return t != v; }) == i );
+
+ ranges::destroy(rx);
+ }
+}
+
+struct X
+{
+ static constexpr int limit = 67;
+ static inline int construct_count = 0;
+ static inline int destruct_count = 0;
+
+ struct exception {};
+
+ bool live = false;
+
+ X()
+ {
+ if (construct_count >= limit)
+ throw exception{};
+ construct_count++;
+ live = true;
+ }
+
+ ~X()
+ {
+ VERIFY( live );
+ live = false;
+ destruct_count++;
+ }
+};
+
+template<bool test_sized>
+void
+test02()
+{
+ constexpr int size = 100;
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(X)*size]);
+ test_forward_range<X> rx((X *)buffer.get(), (X *)buffer.get() + size);
+ try
+ {
+ X::construct_count = 0;
+ X::destruct_count = 0;
+ if constexpr (test_sized)
+ ranges::uninitialized_default_construct_n(rx.begin(), size);
+ else
+ ranges::uninitialized_default_construct(rx);
+ VERIFY( false && "exception not thrown" );
+ }
+ catch (const X::exception&)
+ {
+ VERIFY( X::construct_count == X::limit );
+ VERIFY( X::destruct_count == X::limit );
+ }
+}
+
+int
+main()
+{
+ test01<char>();
+ test01<int>();
+ test01<long long>();
+ test01<float>();
+ test01<double>();
+ test01<std::vector<char>>();
+ test01<std::string>();
+ test01<std::deque<double>>();
+ test01<std::list<std::vector<std::deque<double>>>>();
+ test01<std::unique_ptr<std::string>>();
+
+ test02<false>();
+ test02<true>();
+}
diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_fill/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_fill/constrained.cc
new file mode 100644
index 00000000000..c95fd666942
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_fill/constrained.cc
@@ -0,0 +1,137 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <algorithm>
+#include <cstring>
+#include <deque>
+#include <list>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+using __gnu_test::test_forward_range;
+
+namespace ranges = std::ranges;
+
+template<typename T>
+void
+test01(const T& value)
+{
+ static_assert(std::equality_comparable<T>);
+
+ for (int k = 0; k < 6; k++)
+ {
+ constexpr int size = 1024;
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(T)*size]);
+ std::span<T> rx((T *)buffer.get(), size);
+
+ auto i = rx.cbegin();
+ if (k == 0)
+ i = ranges::uninitialized_fill(rx.begin(), rx.end(), value);
+ else if (k == 1)
+ i = ranges::uninitialized_fill(rx, value);
+ else if (k == 2)
+ i = ranges::uninitialized_fill_n(rx.begin(), 1024, value);
+ else if (k == 3)
+ i = ranges::uninitialized_fill(rx.cbegin(), rx.cend(), value);
+ else if (k == 4)
+ i = ranges::uninitialized_fill(std::as_const(rx), value);
+ else if (k == 5)
+ i = ranges::uninitialized_fill_n(rx.cbegin(), 1024, value);
+ else
+ __builtin_abort();
+
+ VERIFY( i == rx.cend() );
+ VERIFY( ranges::find_if(rx, [&value](const T& v) { return value != v; }) == i );
+
+ ranges::destroy(rx);
+ }
+}
+
+struct X
+{
+ static constexpr int limit = 67;
+ static inline int construct_count = 0;
+ static inline int destruct_count = 0;
+
+ struct exception {};
+
+ bool live = false;
+
+ X(int)
+ {
+ if (construct_count >= limit)
+ throw exception{};
+ construct_count++;
+ live = true;
+ }
+
+ ~X()
+ {
+ VERIFY( live );
+ live = false;
+ destruct_count++;
+ }
+};
+
+template<bool test_sized>
+void
+test02()
+{
+ constexpr int size = 100;
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(X)*size]);
+ test_forward_range<X> rx((X *)buffer.get(), (X *)buffer.get() + size);
+ int value = 5;
+ try
+ {
+ X::construct_count = 0;
+ X::destruct_count = 0;
+ if constexpr (test_sized)
+ ranges::uninitialized_fill_n(rx.begin(), size, value);
+ else
+ ranges::uninitialized_fill(rx, value);
+ VERIFY( false && "exception not thrown" );
+ }
+ catch (const X::exception&)
+ {
+ VERIFY( X::construct_count == X::limit );
+ VERIFY( X::destruct_count == X::limit );
+ }
+}
+
+int
+main()
+{
+ test01<char>(5);
+ test01<int>(3);
+ test01<long long>(17);
+ test01<float>(2.18);
+ test01<double>(3.98);
+ test01<std::vector<char>>({'a', 'b', 'c', 'd'});
+ test01<std::string>("hello");
+ test01<std::deque<double>>({1.1,2.1,3.1});
+ test01<std::list<std::vector<std::deque<double>>>>({{{3.4},{1}},{{7.9}}});
+
+ test02<false>();
+ test02<true>();
+}
diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc
new file mode 100644
index 00000000000..796c7ca8f46
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc
@@ -0,0 +1,176 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <algorithm>
+#include <cstring>
+#include <deque>
+#include <list>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+using __gnu_test::test_input_range;
+using __gnu_test::test_forward_range;
+
+namespace ranges = std::ranges;
+
+template<typename T>
+void
+test01(std::vector<T> ix)
+{
+ static_assert(std::move_constructible<T>);
+ static_assert(std::equality_comparable<T>);
+
+ const auto saved_ix = ix;
+
+ for (int k = 0; k < 7; k++)
+ {
+ ix = saved_ix;
+
+ int size = ix.size();
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(T)*size]);
+ std::span<T> rx((T *)buffer.get(), size);
+
+ ranges::uninitialized_move_result res = {ix.cbegin(), rx.cbegin()};
+ if (k == 0)
+ res = ranges::uninitialized_move(ix.begin(), ix.end(),
+ rx.begin(), rx.end());
+ else if (k == 1)
+ res = ranges::uninitialized_move(ix, rx);
+ else if (k == 2)
+ res = ranges::uninitialized_move_n(ix.begin(), size,
+ rx.begin(), rx.end());
+ else if (k == 3)
+ res = ranges::uninitialized_move(ix.begin(), ix.end(),
+ rx.cbegin(), rx.cend());
+ else if (k == 4)
+ res = ranges::uninitialized_move(ix, std::as_const(rx));
+ else if (k == 5)
+ res = ranges::uninitialized_move_n(ix.begin(), size,
+ rx.cbegin(), rx.cend());
+ else if (k == 6)
+ res = ranges::uninitialized_move_n(ix.begin(), size/2,
+ rx.cbegin(), rx.cend());
+ else if (k == 7)
+ res = ranges::uninitialized_move_n(ix.begin(), size,
+ rx.cbegin(), rx.cbegin()+size/2);
+ else
+ __builtin_abort();
+
+ if (k == 6 || k == 7)
+ {
+ VERIFY( ranges::distance(ix.cbegin(), res.in) == size/2 );
+ VERIFY( ranges::distance(rx.cbegin(), res.out) == size/2 );
+ VERIFY( ranges::equal(saved_ix.begin(), saved_ix.begin()+size/2,
+ rx.begin(), rx.begin()+size/2) );
+ ranges::destroy(rx.begin(), rx.begin()+size/2);
+ }
+ else
+ {
+ VERIFY( res.in == ix.cend() );
+ VERIFY( res.out == rx.cend() );
+ VERIFY( ranges::equal(saved_ix, rx) );
+ ranges::destroy(rx);
+ }
+ }
+}
+
+struct X
+{
+ static constexpr int limit = 67;
+ static inline int move_construct_count = 0;
+ static inline int destruct_count = 0;
+
+ struct exception {};
+
+ bool live = false;
+ bool moved_from = false;
+
+ X()
+ { live = true; moved_from = false; }
+
+ X& operator=(const X&) = delete;
+ X(const X&) = delete;
+
+ X&& operator=(X&&) = delete;
+
+ X(X&& other)
+ {
+ VERIFY( !other.moved_from );
+ other.moved_from = true;
+ live = true;
+ if (move_construct_count >= limit)
+ throw exception{};
+ move_construct_count++;
+ }
+
+ ~X()
+ {
+ VERIFY( live );
+ live = false;
+ destruct_count++;
+ }
+};
+
+template<bool test_sized>
+void
+test02()
+{
+ constexpr int size = 100;
+ X x[size];
+ // FIXME: Should be test_input_range?
+ test_forward_range<X> ix(x);
+
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(X)*size]);
+ test_forward_range<X> rx((X *)buffer.get(), (X *)buffer.get() + size);
+ try
+ {
+ X::move_construct_count = 0;
+ X::destruct_count = 0;
+ if constexpr (test_sized)
+ ranges::uninitialized_move_n(ix.begin(), size, rx.begin(), rx.end());
+ else
+ ranges::uninitialized_move(ix, rx);
+ VERIFY( false && "exception not thrown" );
+ }
+ catch (const X::exception&)
+ {
+ VERIFY( X::move_construct_count == X::limit );
+ VERIFY( X::destruct_count == X::limit );
+ }
+}
+
+int
+main()
+{
+ test01<char>({1,2,3,4,5});
+ test01<int>({1,2,3,4,5});
+ test01<long long>({1,2,3,4,5});
+ test01<float>({1.1,2.1,3.1,4.1});
+ test01<double>({1.1,2.1,3.1,4.1});
+ test01<std::vector<char>>({{'a','b'}, {'c','d'}, {'e','f'}});
+ test01<std::string>({"the", "quick", "brown", "fox"});
+
+ test02<false>();
+ test02<true>();
+}
diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_value_construct/constrained.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_value_construct/constrained.cc
new file mode 100644
index 00000000000..5928bc04c70
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_value_construct/constrained.cc
@@ -0,0 +1,140 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do run { target c++2a } }
+
+#include <algorithm>
+#include <cstring>
+#include <deque>
+#include <list>
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+using __gnu_test::test_forward_range;
+
+namespace ranges = std::ranges;
+
+template<typename T>
+void
+test01()
+{
+ static_assert(std::default_initializable<T>);
+ static_assert(std::equality_comparable<T>);
+
+ for (int k = 0; k < 6; k++)
+ {
+ constexpr int size = 1024;
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(T)*size]);
+ std::span<T> rx((T *)buffer.get(), size);
+
+ T t{};
+
+ auto i = rx.cbegin();
+ if (k == 0)
+ i = ranges::uninitialized_value_construct(rx.begin(), rx.end());
+ else if (k == 1)
+ i = ranges::uninitialized_value_construct(rx);
+ else if (k == 2)
+ i = ranges::uninitialized_value_construct_n(rx.begin(), 1024);
+ else if (k == 3)
+ i = ranges::uninitialized_value_construct(rx.cbegin(), rx.cend());
+ else if (k == 4)
+ i = ranges::uninitialized_value_construct(std::as_const(rx));
+ else if (k == 5)
+ i = ranges::uninitialized_value_construct_n(rx.cbegin(), 1024);
+ else
+ __builtin_abort();
+
+ VERIFY( i == rx.cend() );
+ VERIFY( ranges::find_if(rx, [&t](const T& v) { return t != v; }) == i );
+
+ ranges::destroy(rx);
+ }
+}
+
+struct X
+{
+ static constexpr int limit = 67;
+ static inline int construct_count = 0;
+ static inline int destruct_count = 0;
+
+ struct exception {};
+
+ bool live = false;
+
+ X()
+ {
+ if (construct_count >= limit)
+ throw exception{};
+ construct_count++;
+ live = true;
+ }
+
+ ~X()
+ {
+ VERIFY( live );
+ live = false;
+ destruct_count++;
+ }
+};
+
+template<bool test_sized>
+void
+test02()
+{
+ constexpr int size = 100;
+ auto buffer = std::unique_ptr<char[]>(new char[sizeof(X)*size]);
+ test_forward_range<X> rx((X *)buffer.get(), (X *)buffer.get() + size);
+ try
+ {
+ X::construct_count = 0;
+ X::destruct_count = 0;
+ if constexpr (test_sized)
+ ranges::uninitialized_value_construct_n(rx.begin(), size);
+ else
+ ranges::uninitialized_value_construct(rx);
+ VERIFY( false && "exception not thrown" );
+ }
+ catch (const X::exception&)
+ {
+ VERIFY( X::construct_count == X::limit );
+ VERIFY( X::destruct_count == X::limit );
+ }
+}
+
+int
+main()
+{
+ test01<char>();
+ test01<int>();
+ test01<long long>();
+ test01<float>();
+ test01<double>();
+ test01<std::vector<char>>();
+ test01<std::string>();
+ test01<std::deque<double>>();
+ test01<std::list<std::vector<std::deque<double>>>>();
+ test01<std::unique_ptr<std::string>>();
+
+ test02<false>();
+ test02<true>();
+}
--
2.25.0.191.gde93cc14ab
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 2/2] libstdc++: Implement ranges [specialized.algorithms]
2020-02-12 20:42 ` [PATCH 2/2] libstdc++: Implement ranges [specialized.algorithms] Patrick Palka
@ 2020-02-13 16:12 ` Jonathan Wakely
2020-02-13 20:46 ` Patrick Palka
0 siblings, 1 reply; 5+ messages in thread
From: Jonathan Wakely @ 2020-02-13 16:12 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc-patches, libstdc++
On 12/02/20 15:41 -0500, Patrick Palka wrote:
>This implements all the ranges members defined in [specialized.algorithms]:
>
> ranges::uninitialized_default_construct
> ranges::uninitialized_value_construct
> ranges::uninitialized_copy
> ranges::uninitialized_copy_n
> ranges::uninitialized_move
> ranges::uninitialized_move_n
> ranges::uninitialized_fill
> ranges::uninitialized_fill_n
> ranges::construct_at
> ranges::destroy_at
> ranges::destroy
>
>It also implements (hopefully correctly) the "obvious" optimizations for these
>algos, namely that if the output range has a trivial value type and if the
>appropriate operation won't throw then we can dispatch to the standard ranges
>version of the algorithm which will then potentially enable further
>optimizations.
>
>libstdc++-v3/ChangeLog:
>
> * include/Makefile.am: Add <bits/ranges_uninitialized.h>.
> * include/Makefile.in: Regenerate.
> * include/bits/ranges_uninitialized.h: New header.
> * include/std/memory: Include it.
> * testsuite/20_util/specialized_algorithms/destroy/constrained.cc: New
> test.
> * .../uninitialized_copy/constrained.cc: New test.
> * .../uninitialized_default_construct/constrained.cc: New test.
> * .../uninitialized_fill/constrained.cc: New test.
> * .../uninitialized_move/constrained.cc: New test.
> * .../uninitialized_value_construct/constrained.cc: New test.
>+ template<__detail::__nothrow_input_iterator _Iter,
>+ __detail::__nothrow_sentinel<_Iter> _Sent>
>+ requires destructible<iter_value_t<_Iter>>
>+ constexpr _Iter
>+ destroy(_Iter __first, _Sent __last) noexcept
>+ {
>+ if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
>+ return ranges::next(__first, __last);
>+ else
>+ {
>+ for (; __first != __last; ++__first)
>+ ranges::destroy_at(addressof(*__first));
This should be std::__addressof
>+ return __first;
>+ }
>+ }
>+
>+ template<__detail::__nothrow_input_range _Range>
>+ requires destructible<range_value_t<_Range>>
>+ constexpr safe_iterator_t<_Range>
>+ destroy(_Range&& __r) noexcept
>+ { return ranges::destroy(ranges::begin(__r), ranges::end(__r)); }
>+
>+ template<__detail::__nothrow_input_iterator _Iter>
>+ requires destructible<iter_value_t<_Iter>>
>+ constexpr _Iter
>+ destroy_n(_Iter __first, iter_difference_t<_Iter> __n) noexcept
>+ {
>+ if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
>+ return ranges::next(__first, __n);
>+ else
>+ {
>+ for (; __n > 0; ++__first, (void)--__n)
>+ ranges::destroy_at(addressof(*__first));
Same here.
OK for master with those two adjustments.
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 2/2] libstdc++: Implement ranges [specialized.algorithms]
2020-02-13 16:12 ` Jonathan Wakely
@ 2020-02-13 20:46 ` Patrick Palka
0 siblings, 0 replies; 5+ messages in thread
From: Patrick Palka @ 2020-02-13 20:46 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: Patrick Palka, gcc-patches, libstdc++
On Thu, 13 Feb 2020, Jonathan Wakely wrote:
> On 12/02/20 15:41 -0500, Patrick Palka wrote:
> > This implements all the ranges members defined in [specialized.algorithms]:
> >
> > ranges::uninitialized_default_construct
> > ranges::uninitialized_value_construct
> > ranges::uninitialized_copy
> > ranges::uninitialized_copy_n
> > ranges::uninitialized_move
> > ranges::uninitialized_move_n
> > ranges::uninitialized_fill
> > ranges::uninitialized_fill_n
> > ranges::construct_at
> > ranges::destroy_at
> > ranges::destroy
> >
> > It also implements (hopefully correctly) the "obvious" optimizations for
> > these
> > algos, namely that if the output range has a trivial value type and if the
> > appropriate operation won't throw then we can dispatch to the standard
> > ranges
> > version of the algorithm which will then potentially enable further
> > optimizations.
> >
> > libstdc++-v3/ChangeLog:
> >
> > * include/Makefile.am: Add <bits/ranges_uninitialized.h>.
> > * include/Makefile.in: Regenerate.
> > * include/bits/ranges_uninitialized.h: New header.
> > * include/std/memory: Include it.
> > * testsuite/20_util/specialized_algorithms/destroy/constrained.cc: New
> > test.
> > * .../uninitialized_copy/constrained.cc: New test.
> > * .../uninitialized_default_construct/constrained.cc: New test.
> > * .../uninitialized_fill/constrained.cc: New test.
> > * .../uninitialized_move/constrained.cc: New test.
> > * .../uninitialized_value_construct/constrained.cc: New test.
>
>
>
> > + template<__detail::__nothrow_input_iterator _Iter,
> > + __detail::__nothrow_sentinel<_Iter> _Sent>
> > + requires destructible<iter_value_t<_Iter>>
> > + constexpr _Iter
> > + destroy(_Iter __first, _Sent __last) noexcept
> > + {
> > + if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
> > + return ranges::next(__first, __last);
> > + else
> > + {
> > + for (; __first != __last; ++__first)
> > + ranges::destroy_at(addressof(*__first));
>
> This should be std::__addressof
>
> > + return __first;
> > + }
> > + }
> > +
> > + template<__detail::__nothrow_input_range _Range>
> > + requires destructible<range_value_t<_Range>>
> > + constexpr safe_iterator_t<_Range>
> > + destroy(_Range&& __r) noexcept
> > + { return ranges::destroy(ranges::begin(__r), ranges::end(__r)); }
> > +
> > + template<__detail::__nothrow_input_iterator _Iter>
> > + requires destructible<iter_value_t<_Iter>>
> > + constexpr _Iter
> > + destroy_n(_Iter __first, iter_difference_t<_Iter> __n) noexcept
> > + {
> > + if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
> > + return ranges::next(__first, __n);
> > + else
> > + {
> > + for (; __n > 0; ++__first, (void)--__n)
> > + ranges::destroy_at(addressof(*__first));
>
> Same here.
>
> OK for master with those two adjustments.
Incorporated those two changes and committed both patches. Thanks for
the review!
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h>
2020-02-12 20:42 [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h> Patrick Palka
2020-02-12 20:42 ` [PATCH 2/2] libstdc++: Implement ranges [specialized.algorithms] Patrick Palka
@ 2020-02-13 12:20 ` Jonathan Wakely
1 sibling, 0 replies; 5+ messages in thread
From: Jonathan Wakely @ 2020-02-13 12:20 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc-patches, libstdc++
On 12/02/20 15:41 -0500, Patrick Palka wrote:
>This roughly mirrors the existing split between <bits/stl_algo.h> and
><bits/stl_algobase.h>. The ranges [specialized.algorithms] will use this new
>header to avoid including all of of <bits/ranges_algo.h>.
>
>libstdc++-v3/ChangeLog:
>
> * include/Makefile.am: Add bits/ranges_algobase.h
> * include/Makefile.in: Regenerate.
> * bits/ranges_algo.h: Include <bits/ranges_algobase.h> and refactor
> existing #includes.
> (__detail::__is_normal_iterator, __detail::is_reverse_iterator,
> __detail::__is_move_iterator, copy_result, move_result,
> __equal, equal, copy_result, move_result, move_backward_result,
> copy_backward_result, __copy_or_move_backward, __copy_or_move, copy,
> move, copy_backward, move_backward, copy_n_result, copy_n, fill_n,
> fill): Split out into ...
> * bits/range_algobase.h: ... this new header.
OK for master.
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2020-02-13 20:46 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-02-12 20:42 [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h> Patrick Palka
2020-02-12 20:42 ` [PATCH 2/2] libstdc++: Implement ranges [specialized.algorithms] Patrick Palka
2020-02-13 16:12 ` Jonathan Wakely
2020-02-13 20:46 ` Patrick Palka
2020-02-13 12:20 ` [PATCH 1/2] libstdc++: Move some ranges algos to a new header <bits/ranges_algobase.h> Jonathan Wakely
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).