libstdc++: Implement ranges [specialized.algorithms]

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/ChangeLog

 2020-02-13  Patrick Palka  <ppalka@redhat.com>
 
+	* 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.
+
 	* include/Makefile.am: Add bits/ranges_algobase.h
 	* include/Makefile.in: Regenerate.
 	* bits/ranges_algo.h: Include <bits/ranges_algobase.h> and refactor

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 \

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 \

libstdc++-v3/include/bits/ranges_uninitialized.h

+// 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(std::__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(std::__addressof(*__first));
+	  return __first;
+	}
+    }
+}
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+#endif // concepts
+#endif // C++20
+#endif // _RANGES_UNINITIALIZED_H

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

libstdc++-v3/testsuite/20_util/specialized_algorithms/destroy/constrained.cc

+// 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();
+}

libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_copy/constrained.cc

+// 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>();
+}

libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_default_construct/constrained.cc

+// 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>();
+}

libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_fill/constrained.cc

+// 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>();
+}

libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_move/constrained.cc

+// 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>();
+}

libstdc++-v3/testsuite/20_util/specialized_algorithms/uninitialized_value_construct/constrained.cc

+// 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>();
+}