[ PATCH ] C++20 <span>

JeanHeyd Meneide phdofthehouse@gmail.com
Fri Aug 30 23:42:00 GMT 2019


Ahem -- we were supposed to use the 20 version of the constexpr macro,
not the base one.
I will note that, for some reason, the default constructor was already
constexpr, so we don't change that one!

On Fri, Aug 30, 2019 at 5:11 PM JeanHeyd Meneide
<phdofthehouse@gmail.com> wrote:
>
> On Fri, Aug 30, 2019 at 3:41 PM Jonathan Wakely <jwakely@redhat.com> wrote:
> >
> > On 30/08/19 15:22 -0400, JeanHeyd Meneide wrote:
> > >This patch implements <span> as it currently exists in the C++20 Working Draft.
> >
> > Nice!
> >
> >
> > >Notes:
> > >- __gnu_cxx::__normal_iterator is not fully constexpr, so its not used here
> >
> > I'd prefer to make __normal_iterator constexpr, and use it.
> > It needs to be constexpr anyway for string and vector.
> > ...
>
> Alright, thank you for the feedback. I fixed it up!
>
> Tested x86_64-pc-linux-gnu.
>
> 2019-08-30  JeanHeyd "ThePhD" Meneide  <phdofthehouse@gmail.com>
>
>         * include/std/span: Implement the entirety of span.
>         * include/bits/stl_iterator.h: __gnu_cxx::__normal_iterator<T,
> C> is now constexpr-qualified for C++11+.
>        * include/bits/range_access.h: Add __adl_* versions of access functions.
>         * testsuite/23_containers/span/everything.cc: constexpr and
> non-constexpr tests.
>         * include/Makefile.in: Add span to install.
>         * include/Makefile.am: Likewise
-------------- next part --------------
diff --git a/.gitignore b/.gitignore
index d9d3967a12c..fd116c362ac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -57,3 +57,7 @@ REVISION
 /mpc*
 /gmp*
 /isl*
+
+# ignore sprinkled in dev files that keep popping up
+.vscode/
+.vs/
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 3fe80f32cc4..b8b786d9260 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -68,6 +68,7 @@ std_headers = \
 	${std_srcdir}/scoped_allocator \
 	${std_srcdir}/set \
 	${std_srcdir}/shared_mutex \
+	${std_srcdir}/span \
 	${std_srcdir}/sstream \
 	${std_srcdir}/stack \
 	${std_srcdir}/stdexcept \
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index b675d356cd4..cd1e9df5482 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -412,6 +412,7 @@ std_headers = \
 	${std_srcdir}/scoped_allocator \
 	${std_srcdir}/set \
 	${std_srcdir}/shared_mutex \
+	${std_srcdir}/span \
 	${std_srcdir}/sstream \
 	${std_srcdir}/stack \
 	${std_srcdir}/stdexcept \
diff --git a/libstdc++-v3/include/bits/range_access.h b/libstdc++-v3/include/bits/range_access.h
index d1e74711433..3acaebadcf1 100644
--- a/libstdc++-v3/include/bits/range_access.h
+++ b/libstdc++-v3/include/bits/range_access.h
@@ -318,6 +318,72 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 #endif // C++17
 
+#if __cplusplus > 201703L
+  // "why are these in namespace std:: and not __gnu_cxx:: ?"
+  // because if we don't put them here it's impossible to 
+  // have implicit ADL with "using std::begin/end/size/data;".
+  template <typename _Container>
+    constexpr auto
+    __adl_begin(_Container& __cont) noexcept(noexcept(begin(__cont)))
+    { return begin(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_end(_Container& __cont) noexcept(noexcept(end(__cont)))
+    { return end(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_cbegin(_Container& __cont) noexcept(noexcept(cbegin(__cont)))
+    { return cbegin(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_cend(_Container& __cont) noexcept(noexcept(cend(__cont)))
+    { return cend(__cont); }
+
+  template <typename _Container>
+    constexpr auto
+    __adl_rbegin(_Container& __cont) noexcept(noexcept(rbegin(__cont)))
+    { return rbegin(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_rend(_Container& __cont) noexcept(noexcept(rend(__cont)))
+    { return rend(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_crbegin(_Container& __cont) noexcept(noexcept(crbegin(__cont)))
+    { return crbegin(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_crend(_Container& __cont) noexcept(noexcept(crend(__cont)))
+    { return crend(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_data(_Container& __cont) noexcept(noexcept(data(__cont)))
+    { return data(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_cdata(_Container& __cont) noexcept(noexcept(cdata(__cont)))
+    { return cdata(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_size(_Container& __cont) noexcept(noexcept(size(__cont)))
+    { return size(__cont); }
+  
+  template <typename _Container>
+    constexpr auto
+    __adl_empty(_Container& __cont) noexcept(noexcept(empty(__cont)))
+    { return empty(__cont); }
+  
+#endif // C++20
+
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
 
diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h
index 8ab0d72b0c2..f6a6060f2e3 100644
--- a/libstdc++-v3/include/bits/stl_iterator.h
+++ b/libstdc++-v3/include/bits/stl_iterator.h
@@ -799,55 +799,58 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef typename __traits_type::reference 	reference;
       typedef typename __traits_type::pointer   	pointer;
 
+      // this was already constexpr
+      // so it will not be changed to
+      // _GLIBCXX_CONSTEXPR20
       _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
       : _M_current(_Iterator()) { }
 
       explicit
-      __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
+      _GLIBCXX_CONSTEXPR20 __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
       : _M_current(__i) { }
 
       // Allow iterator to const_iterator conversion
       template<typename _Iter>
-        __normal_iterator(const __normal_iterator<_Iter,
+        _GLIBCXX_CONSTEXPR20 __normal_iterator(const __normal_iterator<_Iter,
 			  typename __enable_if<
       	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
 		      _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
         : _M_current(__i.base()) { }
 
       // Forward iterator requirements
-      reference
+      _GLIBCXX_CONSTEXPR20 reference
       operator*() const _GLIBCXX_NOEXCEPT
       { return *_M_current; }
 
-      pointer
+      _GLIBCXX_CONSTEXPR20 pointer
       operator->() const _GLIBCXX_NOEXCEPT
       { return _M_current; }
 
-      __normal_iterator&
+      _GLIBCXX_CONSTEXPR20 __normal_iterator&
       operator++() _GLIBCXX_NOEXCEPT
       {
 	++_M_current;
 	return *this;
       }
 
-      __normal_iterator
+      _GLIBCXX_CONSTEXPR20 __normal_iterator
       operator++(int) _GLIBCXX_NOEXCEPT
       { return __normal_iterator(_M_current++); }
 
       // Bidirectional iterator requirements
-      __normal_iterator&
+      _GLIBCXX_CONSTEXPR20 __normal_iterator&
       operator--() _GLIBCXX_NOEXCEPT
       {
 	--_M_current;
 	return *this;
       }
 
-      __normal_iterator
+      _GLIBCXX_CONSTEXPR20 __normal_iterator
       operator--(int) _GLIBCXX_NOEXCEPT
       { return __normal_iterator(_M_current--); }
 
       // Random access iterator requirements
-      reference
+      _GLIBCXX_CONSTEXPR20 reference
       operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
       { return _M_current[__n]; }
 
@@ -855,19 +858,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
       { _M_current += __n; return *this; }
 
-      __normal_iterator
+      _GLIBCXX_CONSTEXPR20 __normal_iterator
       operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
       { return __normal_iterator(_M_current + __n); }
 
-      __normal_iterator&
+      _GLIBCXX_CONSTEXPR20 __normal_iterator&
       operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
       { _M_current -= __n; return *this; }
 
-      __normal_iterator
+      _GLIBCXX_CONSTEXPR20 __normal_iterator
       operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
       { return __normal_iterator(_M_current - __n); }
 
-      const _Iterator&
+      _GLIBCXX_CONSTEXPR20 const _Iterator&
       base() const _GLIBCXX_NOEXCEPT
       { return _M_current; }
     };
@@ -882,28 +885,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   // Forward iterator requirements
   template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	       const __normal_iterator<_IteratorR, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() == __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
 	       const __normal_iterator<_Iterator, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() == __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	       const __normal_iterator<_IteratorR, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() != __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
 	       const __normal_iterator<_Iterator, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
@@ -911,56 +914,56 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   // Random access iterator requirements
   template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	      const __normal_iterator<_IteratorR, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() < __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
 	      const __normal_iterator<_Iterator, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() < __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	      const __normal_iterator<_IteratorR, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() > __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
 	      const __normal_iterator<_Iterator, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() > __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	       const __normal_iterator<_IteratorR, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() <= __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
 	       const __normal_iterator<_Iterator, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() <= __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	       const __normal_iterator<_IteratorR, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() >= __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline bool
+    _GLIBCXX_CONSTEXPR20 inline bool
     operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
 	       const __normal_iterator<_Iterator, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
@@ -973,26 +976,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _IteratorL, typename _IteratorR, typename _Container>
 #if __cplusplus >= 201103L
     // DR 685.
-    inline auto
+    _GLIBCXX_CONSTEXPR20 inline auto
     operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	      const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
     -> decltype(__lhs.base() - __rhs.base())
 #else
-    inline typename __normal_iterator<_IteratorL, _Container>::difference_type
+    _GLIBCXX_CONSTEXPR20 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
     operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
 	      const __normal_iterator<_IteratorR, _Container>& __rhs)
 #endif
     { return __lhs.base() - __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline typename __normal_iterator<_Iterator, _Container>::difference_type
+    _GLIBCXX_CONSTEXPR20 inline typename __normal_iterator<_Iterator, _Container>::difference_type
     operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
 	      const __normal_iterator<_Iterator, _Container>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() - __rhs.base(); }
 
   template<typename _Iterator, typename _Container>
-    inline __normal_iterator<_Iterator, _Container>
+    _GLIBCXX_CONSTEXPR20 inline __normal_iterator<_Iterator, _Container>
     operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
 	      __n, const __normal_iterator<_Iterator, _Container>& __i)
     _GLIBCXX_NOEXCEPT
@@ -1006,7 +1009,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<typename _Iterator, typename _Container>
-    _Iterator
+    _GLIBCXX_CONSTEXPR20 _Iterator
     __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
     _GLIBCXX_NOEXCEPT_IF(std::is_nothrow_copy_constructible<_Iterator>::value)
     { return __it.base(); }
diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span
new file mode 100644
index 00000000000..e4a30977585
--- /dev/null
+++ b/libstdc++-v3/include/std/span
@@ -0,0 +1,571 @@
+// Components for manipulating non-owning sequences of objects -*- C++ -*-
+
+// Copyright (C) 2019 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 span
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// P0122 span library
+// Contributed by ThePhD
+//
+
+#ifndef _GLIBCXX_SPAN
+#define _GLIBCXX_SPAN 1
+
+#pragma GCC system_header
+
+#if __cplusplus > 201703L
+
+#include <cstddef>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+#include <array>
+#include <bits/stl_iterator.h>
+#include <bits/range_access.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+// FIXME: they forgot this feature test macro
+// get on someone's back about it in Belfast!!!
+#define __cpp_lib_span 201911
+
+  inline constexpr size_t dynamic_extent =
+    static_cast<size_t>(-1);
+
+  namespace __detail
+  {
+
+    template<typename _Element, typename _ToElement>
+    using __is_base_derived_safe_convertible =
+      is_convertible<_Element (*)[], _ToElement (*)[]>;
+
+    template<typename _Element, typename _ToElement>
+    static constexpr inline bool __is_base_derived_safe_convertible_v =
+      __is_base_derived_safe_convertible<_Element, _ToElement>::value;
+
+    template<typename>
+    struct __is_std_array : false_type
+    {
+    };
+
+    template<typename _Element, size_t _Extent>
+    struct __is_std_array<::std::array<_Element, _Extent>> : true_type
+    {
+    };
+
+#ifdef _GLIBCXX_DEBUG
+    template<typename _Element, size_t _Extent>
+    struct __is_std_array<::std::__debug::array<_Element, _Extent>>
+    : true_type
+    {
+    };
+#endif // debug/array
+
+    template<typename _Type>
+    inline constexpr bool __is_std_array_v = __is_std_array<_Type>::value;
+
+    template<size_t _Extent>
+    struct __extent_storage
+    {
+
+      constexpr __extent_storage() noexcept = default;
+      constexpr __extent_storage(size_t) noexcept
+      {
+      }
+
+      static constexpr size_t
+      _M_extent() noexcept
+      {
+        return _Extent;
+      }
+    };
+
+    template<>
+    struct __extent_storage<static_cast<size_t>(-1)>
+    {
+      size_t _M_extent_value;
+
+      constexpr __extent_storage() noexcept : _M_extent_value(0){};
+      constexpr __extent_storage(size_t __extent) noexcept
+      : _M_extent_value(__extent)
+      {
+      }
+
+      constexpr size_t
+      _M_extent() const noexcept
+      {
+        return this->_M_extent_value;
+      }
+    };
+
+  } // namespace __detail
+
+  template<typename _Type, size_t _Extent = dynamic_extent>
+  class span : private __detail::__extent_storage<_Extent>
+  {
+  public:
+    // member types
+    using value_type             = remove_cv_t<_Type>;
+    using element_type           = _Type;
+    using index_type             = size_t;
+    using reference              = element_type&;
+    using const_reference        = const element_type&;
+    using pointer                = _Type*;
+    using const_pointer          = const _Type*;
+    using iterator               = __gnu_cxx::__normal_iterator<pointer, span>;
+    using const_iterator         = __gnu_cxx::__normal_iterator<const_pointer, span>;
+    using reverse_iterator       = ::std::reverse_iterator<iterator>;
+    using const_reverse_iterator = ::std::reverse_iterator<const_iterator>;
+    using difference_type        = ptrdiff_t;
+    // Official wording has no size_type -- why??
+    // using size_type = size_t;
+
+    // member constants
+    static inline constexpr size_t extent = _Extent;
+
+  private:
+    using __base_t = __detail::__extent_storage<_Extent>;
+
+  public:
+    // constructors
+    constexpr span() noexcept : __base_t(), _M_ptr(nullptr)
+    {
+    }
+
+    constexpr span(const span&) noexcept = default;
+
+    template<size_t _ArrayExtent,
+      enable_if_t<
+        (_Extent == dynamic_extent || _ArrayExtent == _Extent) &&
+        __detail::__is_base_derived_safe_convertible_v<
+          remove_pointer_t<decltype(::std::__adl_data(
+            ::std::declval<element_type (&)[_ArrayExtent]>()))>,
+          element_type>>* = nullptr>
+    constexpr span(element_type (&__arr)[_ArrayExtent]) noexcept(
+      noexcept(::std::__adl_data(__arr)))
+    : span(::std::__adl_data(__arr), _ArrayExtent)
+    {
+    }
+
+    template<size_t _ArrayExtent,
+      enable_if_t<
+        (_Extent == dynamic_extent || _ArrayExtent == _Extent) &&
+        __detail::__is_base_derived_safe_convertible_v<
+          remove_pointer_t<decltype(::std::__adl_data(
+            ::std::declval<array<value_type, _ArrayExtent>&>()))>,
+          element_type>>* = nullptr>
+    constexpr span(array<value_type, _ArrayExtent>& __arr) noexcept(
+      noexcept(::std::__adl_data(__arr)))
+    : span(::std::__adl_data(__arr), _ArrayExtent)
+    {
+    }
+
+    template<size_t _ArrayExtent,
+      enable_if_t<
+        (_Extent == dynamic_extent || _ArrayExtent == _Extent) &&
+        __detail::__is_base_derived_safe_convertible_v<
+          remove_pointer_t<decltype(::std::__adl_data(
+            ::std::declval<const array<value_type, _ArrayExtent>&>()))>,
+          element_type>>* = nullptr>
+    constexpr span(const array<value_type, _ArrayExtent>&
+        __arr) noexcept(noexcept(::std::__adl_data(__arr)))
+    : span(::std::__adl_data(__arr), _ArrayExtent)
+    {
+    }
+
+    // NOTE: when the time comes, and P1394 -
+    // range constructors for std::span - ships in
+    // the standard, delete the #else block and remove
+    // the conditional
+    // if the paper fails, delete #if block
+    // and keep the crappy #else block
+    // and then cry that NB comments failed C++20...
+    // but maybe for C++23?
+#if defined(_GLIBCXX_P1394) && _GLIBCXX_P1394
+    template<typename _Range,
+      enable_if_t<
+        (_Extent == dynamic_extent) &&
+        !is_same_v<remove_cvref_t<_Range>, span> &&
+        !__detail::__is_std_array_v<remove_cvref_t<_Range>> &&
+        !is_array_v<remove_cvref_t<_Range>> &&
+        __detail::__is_base_derived_safe_convertible_v<
+          remove_pointer_t<decltype(
+            ::std::__adl_data(::std::declval<_Range&>()))>,
+          element_type>>* = nullptr>
+    constexpr span(_Range&& __range) noexcept(
+      noexcept(::std::__adl_data(__range)) &&
+      noexcept(::std::__adl_size(__range)))
+    : span(::std::__adl_data(__range), ::std::__adl_size(__range))
+    {
+    }
+
+    template<typename _ContiguousIterator, typename _Sentinel,
+      enable_if_t<!is_convertible_v<_Sentinel, index_type> &&
+                         __detail::__is_base_derived_safe_convertible_v<
+                           remove_reference_t<typename 
+                               iterator_traits<_ContiguousIterator>::reference>,
+                           element_type>>* = nullptr>
+    constexpr span(_ContiguousIterator __first, _Sentinel __last)
+    : span(::std::move(__first), static_cast<index_type>(__last - __first))
+    {
+    }
+
+    template<typename _ContiguousIterator>
+    constexpr span(_ContiguousIterator __first, index_type __count) noexcept(
+      noexcept(::std::to_address(__first)))
+    : __base_t(__count), _M_ptr(::std::to_address(__first))
+    {
+    }
+#else
+    template<typename _Container,
+      enable_if_t<
+        (_Extent == dynamic_extent) &&
+        !is_same_v<remove_cvref_t<_Container>, span> &&
+        !__detail::__is_std_array_v<remove_cvref_t<_Container>> &&
+        !is_array_v<remove_cvref_t<_Container>> &&
+        __detail::__is_base_derived_safe_convertible_v<
+          remove_pointer_t<decltype(
+            ::std::__adl_data(::std::declval<_Container&>()))>,
+          element_type>>* = nullptr>
+    constexpr span(_Container& __range) noexcept(
+      noexcept(::std::__adl_data(__range)) &&
+      noexcept(::std::__adl_size(__range)))
+    : span(::std::__adl_data(__range), ::std::__adl_size(__range))
+    {
+    }
+
+    template<typename _Container,
+      enable_if_t<
+        (_Extent == dynamic_extent) &&
+        !is_same_v<remove_cvref_t<_Container>, span> &&
+        !__detail::__is_std_array_v<remove_cvref_t<_Container>> &&
+        !is_array_v<remove_cvref_t<_Container>> &&
+        __detail::__is_base_derived_safe_convertible_v<
+          remove_pointer_t<decltype(
+            ::std::__adl_data(::std::declval<_Container&>()))>,
+          element_type>>* = nullptr>
+    constexpr span(const _Container& __range) noexcept(
+      noexcept(::std::__adl_data(__range)) &&
+      noexcept(::std::__adl_size(__range)))
+    : span(::std::__adl_data(__range), ::std::__adl_size(__range))
+    {
+    }
+
+    constexpr span(pointer __first, pointer __last) noexcept
+    : span(::std::move(__first), static_cast<index_type>(__last - __first))
+    {
+    }
+    constexpr span(pointer __first, index_type __count) noexcept
+    : __base_t(__count), _M_ptr(static_cast<pointer>(__first))
+    {
+    }
+#endif // P1394
+
+    // assignment
+    constexpr span&
+    operator=(const span&) noexcept = default;
+
+    // observers
+    constexpr reference
+    front() noexcept
+    {
+      return *this->begin();
+    }
+
+    constexpr const_reference
+    front() const noexcept
+    {
+      return *this->begin();
+    }
+
+    constexpr reference
+    back() noexcept
+    {
+      return *(this->begin() + 1);
+    }
+
+    constexpr const_reference
+    back() const noexcept
+    {
+      return *(this->end() - 1);
+    }
+
+    constexpr reference operator[](index_type __idx) noexcept
+    {
+      return *(this->_M_ptr + __idx);
+    }
+
+    constexpr const_reference operator[](index_type __idx) const noexcept
+    {
+      return *(this->_M_ptr + __idx);
+    }
+
+    constexpr pointer
+    data() const noexcept
+    {
+      return this->_M_ptr;
+    }
+
+    constexpr index_type
+    size() const noexcept
+    {
+      return this->__base_t::_M_extent();
+    }
+
+    constexpr index_type
+    size_bytes() const noexcept
+    {
+      return this->__base_t::_M_extent() * sizeof(element_type);
+    }
+
+    constexpr bool
+    empty() const noexcept
+    {
+      return size() == 0;
+    }
+
+    // observers: iterators
+    constexpr iterator
+    begin() const noexcept
+    {
+      return iterator(this->_M_ptr);
+    }
+
+    constexpr const_iterator
+    cbegin() const noexcept
+    {
+      return const_iterator(this->_M_ptr);
+    }
+
+    constexpr iterator
+    end() const noexcept
+    {
+      return iterator(this->_M_ptr + this->size());
+    }
+
+    constexpr const_iterator
+    cend() const noexcept
+    {
+      return const_iterator(this->_M_ptr + this->size());
+    }
+
+    constexpr reverse_iterator
+    rbegin() const noexcept
+    {
+      return reverse_iterator(this->begin());
+    }
+
+    constexpr const_reverse_iterator
+    crbegin() const noexcept
+    {
+      return const_reverse_iterator(this->cbegin());
+    }
+
+    constexpr reverse_iterator
+    rend() const noexcept
+    {
+      return reverse_iterator(this->end());
+    }
+
+    constexpr const_reverse_iterator
+    crend() const noexcept
+    {
+      return const_reverse_iterator(this->cend());
+    }
+
+    // observers: subranges
+    template<size_t _Count>
+    constexpr auto
+    first() const
+    {
+      using __span_t = ::std::span<element_type, _Count>;
+      return __span_t(this->data(), _Count);
+    }
+
+    constexpr auto
+    first(index_type __count) const
+    {
+      using __span_t = ::std::span<element_type, dynamic_extent>;
+      return __span_t(this->data(), __count);
+    }
+
+    template<size_t _Count>
+    constexpr ::std::span<element_type, _Count>
+    last() const
+    {
+      static_assert(_Count == dynamic_extent ||
+                      _Extent == dynamic_extent || _Count <= _Extent,
+        "assertion failed: Count or Extent are dynamic, "
+        "or the Count is less than the static extent");
+      using __span_t = ::std::span<element_type, _Count>;
+      return __span_t(this->data() + (this->size() - _Count), _Count);
+    }
+
+    constexpr auto
+    last(index_type __count) const
+    {
+      using __span_t = ::std::span<element_type, dynamic_extent>;
+      return __span_t(this->data() + (this->size() - __count), __count);
+    }
+
+    template<size_t _Offset,
+      size_t _Count = dynamic_extent>
+    constexpr auto
+    subspan() const
+    {
+      static_assert(_Count == dynamic_extent ||
+                      _Extent == dynamic_extent ||
+                      (_Offset + _Count) <= _Extent,
+        "assertion failed: Count or Extent are dynamic, "
+        "or the Count + Offset is less than the static extent");
+      constexpr size_t __span_extent =
+        (_Count != dynamic_extent
+            ? _Count
+            : (_Extent != dynamic_extent ? _Extent - _Offset
+                                                : dynamic_extent));
+      using __span_t = ::std::span<element_type, __span_extent>;
+      return __span_t(this->data() + _Offset,
+        (_Count == dynamic_extent ? this->size() - _Offset : _Count));
+    }
+
+    constexpr auto
+    subspan(
+      index_type __offset, index_type __count = dynamic_extent) const
+    {
+      using __span_t = ::std::span<element_type, dynamic_extent>;
+      return __span_t(this->data() + __offset,
+        __count == dynamic_extent ? this->size() - __offset : __count);
+    }
+
+    // observers: range helpers
+    friend constexpr iterator
+    begin(span __sp) noexcept
+    {
+      return __sp.begin();
+    }
+
+    friend constexpr iterator
+    end(span __sp) noexcept
+    {
+      return __sp.end();
+    }
+
+  private:
+    pointer _M_ptr;
+  };
+
+  template<typename _Type, size_t _Extent>
+  auto as_bytes(::std::span<_Type, _Extent> __sp) noexcept
+  {
+    constexpr size_t __byte_extent =
+      (_Extent == ::std::dynamic_extent
+          ? _Extent
+          : (_Extent *
+              sizeof(typename ::std::span<_Type, _Extent>::element_type)));
+    using __byte_span_t = ::std::span<const byte, __byte_extent>;
+    return __byte_span_t(
+      reinterpret_cast<const byte*>(__sp.data()), __sp.size_bytes());
+  }
+
+  template<typename _Type, size_t _Extent>
+  auto as_writable_bytes(::std::span<_Type, _Extent> __sp) noexcept
+  {
+    constexpr size_t __byte_extent =
+      (_Extent == dynamic_extent
+          ? _Extent
+          : (_Extent *
+              sizeof(typename ::std::span<_Type, _Extent>::element_type)));
+    using __byte_span_t = ::std::span<byte, __byte_extent>;
+    return __byte_span_t(
+      reinterpret_cast<byte*>(__sp.data()), __sp.size_bytes());
+  }
+
+  // tuple helpers
+  template<size_t _Index, typename _Type, size_t _Extent,
+    enable_if_t<(_Extent > 0) && (_Index < _Extent)>* = nullptr>
+  constexpr typename ::std::span<_Type, _Extent>::reference get(
+    ::std::span<_Type, _Extent> __sp) noexcept
+  {
+    return __sp[_Index];
+  }
+
+  template<typename _Type, size_t _Extent>
+  class tuple_size<::std::span<_Type, _Extent>>
+  : public integral_constant<size_t, _Extent>
+  {
+  };
+
+  template<typename _Type>
+  class tuple_size<::std::span<_Type, dynamic_extent>>;
+
+  template<size_t _Index, typename _Type, size_t _Extent>
+  struct tuple_element<_Index, ::std::span<_Type, _Extent>>
+  {
+    static_assert(_Index < _Extent, "assertion failed: Index is less than Extent");
+    using type = typename ::std::span<_Type, _Extent>::element_type;
+  };
+
+  // deduction guides
+  template<typename _Type, size_t _ArrayExtent>
+  span(_Type(&)[_ArrayExtent])->span<_Type, _ArrayExtent>;
+
+  template<typename _Type, size_t _ArrayExtent>
+  span(array<_Type, _ArrayExtent>&)->span<_Type, _ArrayExtent>;
+
+  template<typename _Type, size_t _ArrayExtent>
+  span(const array<_Type, _ArrayExtent>&)
+    ->span<const _Type, _ArrayExtent>;
+
+#if defined(_GLIBCXX_P1394) && _GLIBCXX_P1394
+
+  template<typename _ContiguousIterator, typename _Sentinel>
+  span(_ContiguousIterator, _Sentinel)
+    ->span<remove_reference_t<
+      typename iterator_traits<_ContiguousIterator>::reference>>;
+
+  template<typename _Range>
+  span(_Range &&)
+    ->span<remove_reference_t<typename iterator_traits<decltype(
+      ::std::__adl_begin(::std::declval<_Range&>()))>::reference>>;
+
+#else
+
+  template<typename _Container>
+  span(_Container&)->span<typename _Container::value_type>;
+
+  template<typename _Container>
+  span(const _Container&)->span<const typename _Container::value_type>;
+
+#endif // P1394
+
+  _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std_GLIBCXX_VISIBILITY(default)
+
+#endif // C++20
+
+#endif
diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version
index 7f7d05fd8f2..4341c9f0c1b 100644
--- a/libstdc++-v3/include/std/version
+++ b/libstdc++-v3/include/std/version
@@ -167,6 +167,9 @@
 #define __cpp_lib_list_remove_return_type 201806L
 #define __cpp_lib_math_constants 201907L
 #define __cpp_lib_to_array 201907L
+// FIXME: they forgot this feature test macro
+// get on someone's back about it in Belfast!!!
+#define __cpp_lib_span 201911
 #endif // C++2a
 #endif // C++17
 #endif // C++14
diff --git a/libstdc++-v3/testsuite/23_containers/span/everything.cc b/libstdc++-v3/testsuite/23_containers/span/everything.cc
new file mode 100644
index 00000000000..4a9ba442c68
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/span/everything.cc
@@ -0,0 +1,203 @@
+// Copyright (C) 2019 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=c++2a" }
+// { dg-do run { target c++2a } }
+
+#include <testsuite_hooks.h>
+
+#include <span>
+#include <type_traits>
+#include <cstdint>
+#include <vector>
+#include <algorithm>
+#include <cassert>
+
+int
+main()
+{
+  struct alignas(256) strawman
+  {
+    int x;
+    int y;
+    bool z;
+    int w;
+  };
+
+  struct naked_span
+  {
+    char* p;
+    std::size_t n;
+  };
+
+  struct strawman_span
+  {
+    strawman* p;
+    std::size_t n;
+  };
+
+  static_assert(sizeof(std::span<char, 0>) <= sizeof(char*));
+  static_assert(sizeof(std::span<const char, 0>) <= sizeof(const char*));
+  static_assert(sizeof(std::span<strawman, 0>) <= sizeof(strawman*));
+  static_assert(sizeof(std::span<strawman, 1>) <= sizeof(strawman*));
+  static_assert(sizeof(std::span<char>) <= sizeof(naked_span));
+  static_assert(sizeof(std::span<strawman>) <= sizeof(naked_span));
+
+  constexpr static std::array<int, 9> arr_data{ 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+  constexpr auto arr_data_span = std::span(arr_data);
+  static_assert(arr_data_span.size() == 9);
+  static_assert(arr_data_span.size_bytes() == 9 * sizeof(int));
+  static_assert(*arr_data_span.begin() == 0);
+  static_assert(*arr_data_span.data() == 0);
+  static_assert(arr_data_span.front() == 0);
+  static_assert(arr_data_span.back() == 8);
+  static_assert(arr_data_span[0] == 0);
+  static_assert(arr_data_span[1] == 1);
+  static_assert(arr_data_span[2] == 2);
+  static_assert(arr_data_span[3] == 3);
+  static_assert(arr_data_span[4] == 4);
+  static_assert(arr_data_span[5] == 5);
+  static_assert(arr_data_span[6] == 6);
+  static_assert(arr_data_span[7] == 7);
+  static_assert(arr_data_span[8] == 8);
+  static_assert(!arr_data_span.empty());
+  static_assert(decltype(arr_data_span)::extent == 9);
+
+  constexpr static int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+  constexpr auto data_span    = std::span(data);
+  static_assert(data_span.size() == 9);
+  static_assert(data_span.size_bytes() == 9 * sizeof(int));
+  static_assert(*data_span.begin() == 0);
+  static_assert(*data_span.data() == 0);
+  static_assert(data_span.front() == 0);
+  static_assert(data_span.back() == 8);
+  static_assert(data_span[0] == 0);
+  static_assert(data_span[1] == 1);
+  static_assert(data_span[2] == 2);
+  static_assert(data_span[3] == 3);
+  static_assert(data_span[4] == 4);
+  static_assert(data_span[5] == 5);
+  static_assert(data_span[6] == 6);
+  static_assert(data_span[7] == 7);
+  static_assert(data_span[8] == 8);
+  static_assert(!data_span.empty());
+  static_assert(decltype(data_span)::extent == 9);
+
+  constexpr auto data_span_first = data_span.first<3>();
+  static_assert(
+    std::is_same_v<std::remove_cv_t<decltype(data_span_first)>, std::span<const int, 3>>);
+  static_assert(decltype(data_span_first)::extent == 3);
+  static_assert(data_span_first.size() == 3);
+  static_assert(data_span_first.front() == 0);
+  static_assert(data_span_first.back() == 2);
+  static_assert(std::tuple_size_v<decltype(data_span_first)> == 3);
+  static_assert(std::is_same_v<std::tuple_element_t<0, decltype(data_span_first)>, const int>);
+
+  constexpr auto data_span_first_dyn = data_span.first(4);
+  static_assert(
+    std::is_same_v<std::remove_cv_t<decltype(data_span_first_dyn)>, std::span<const int>>);
+  static_assert(decltype(data_span_first_dyn)::extent == std::dynamic_extent);
+  static_assert(data_span_first_dyn.size() == 4);
+  static_assert(data_span_first_dyn.front() == 0);
+  static_assert(data_span_first_dyn.back() == 3);
+
+  constexpr auto data_span_last = data_span.last<5>();
+  static_assert(
+    std::is_same_v<std::remove_cv_t<decltype(data_span_last)>, std::span<const int, 5>>);
+  static_assert(decltype(data_span_last)::extent == 5);
+  static_assert(data_span_last.size() == 5);
+  static_assert(data_span_last.front() == 4);
+  static_assert(data_span_last.back() == 8);
+  static_assert(std::tuple_size_v<decltype(data_span_last)> == 5);
+  static_assert(std::is_same_v<std::tuple_element_t<0, decltype(data_span_last)>, const int>);
+
+  constexpr auto data_span_last_dyn = data_span.last(6);
+  static_assert(
+    std::is_same_v<std::remove_cv_t<decltype(data_span_last_dyn)>, std::span<const int>>);
+  static_assert(decltype(data_span_last_dyn)::extent == std::dynamic_extent);
+  static_assert(data_span_last_dyn.size() == 6);
+  static_assert(data_span_last_dyn.front() == 3);
+  static_assert(data_span_last_dyn.back() == 8);
+
+  constexpr auto data_span_subspan = data_span.subspan<1, 3>();
+  static_assert(
+    std::is_same_v<std::remove_cv_t<decltype(data_span_subspan)>, std::span<const int, 3>>);
+  static_assert(decltype(data_span_subspan)::extent == 3);
+  static_assert(data_span_subspan.size() == 3);
+  static_assert(data_span_subspan.front() == 1);
+  static_assert(data_span_subspan.back() == 3);
+
+  constexpr auto data_span_subspan_offset = data_span.subspan<8>();
+  static_assert(
+    std::is_same_v<std::remove_cv_t<decltype(data_span_subspan_offset)>, std::span<const int, 1>>);
+  static_assert(decltype(data_span_subspan_offset)::extent == 1);
+  static_assert(data_span_subspan_offset.size() == 1);
+  static_assert(data_span_subspan_offset.front() == 8);
+  static_assert(data_span_subspan_offset.back() == 8);
+
+  constexpr auto data_span_subspan_empty = data_span.subspan(9, 0);
+  static_assert(
+    std::is_same_v<std::remove_cv_t<decltype(data_span_subspan_empty)>, std::span<const int>>);
+  static_assert(decltype(data_span_subspan_empty)::extent == std::dynamic_extent);
+  static_assert(data_span_subspan_empty.size() == 0);
+
+  constexpr auto data_span_subspan_empty_static = data_span.subspan<9>();
+  static_assert(std::is_same_v<std::remove_cv_t<decltype(data_span_subspan_empty_static)>,
+    std::span<const int, 0>>);
+  static_assert(decltype(data_span_subspan_empty_static)::extent == 0);
+  static_assert(data_span_subspan_empty.size() == 0);
+
+  std::span<short> shorts{};
+  bool really_empty0 = shorts.empty();
+  bool really_empty1 = std::empty(shorts);
+  bool really_empty2 = shorts.data() == nullptr;
+  bool really_empty3 = shorts.begin() == shorts.end();
+  bool really_empty4 = shorts.cbegin() == shorts.cend();
+  bool really_empty =
+    really_empty0 && really_empty1 && really_empty2 && really_empty3 && really_empty4;
+  (void)really_empty;
+  VERIFY(really_empty);
+
+  std::vector<std::int_least32_t> value{ 0 };
+  std::span<int32_t> muh_span(value);
+  VERIFY(muh_span.size() == 1);
+  std::byte* original_bytes                  = reinterpret_cast<std::byte*>(value.data());
+  original_bytes[0]                          = static_cast<std::byte>(1);
+  original_bytes[1]                          = static_cast<std::byte>(2);
+  original_bytes[2]                          = static_cast<std::byte>(3);
+  original_bytes[3]                          = static_cast<std::byte>(4);
+  std::span<const std::byte> muh_byte_span   = std::as_bytes(muh_span);
+  std::span<std::byte> muh_mutable_byte_span = std::as_writable_bytes(muh_span);
+  std::span<std::byte> muh_original_byte_span(original_bytes, original_bytes + 4);
+  bool definitely_reinterpret_casted0 = std::equal(muh_byte_span.cbegin(), muh_byte_span.cend(),
+    muh_original_byte_span.cbegin(), muh_original_byte_span.cend());
+  bool definitely_reinterpret_casted1 = std::equal(muh_mutable_byte_span.cbegin(),
+    muh_mutable_byte_span.cend(), muh_original_byte_span.cbegin(), muh_original_byte_span.cend());
+  bool definitely_reinterpret_casted =
+    definitely_reinterpret_casted0 && definitely_reinterpret_casted1;
+  (void)definitely_reinterpret_casted;
+  VERIFY(definitely_reinterpret_casted);
+
+  std::span<std::byte> muh_original_byte_span_ptr_size(original_bytes, 4);
+  bool definitely_equivalent =
+    std::equal(muh_original_byte_span_ptr_size.cbegin(), muh_original_byte_span_ptr_size.cend(),
+      muh_original_byte_span.cbegin(), muh_original_byte_span.cend());
+  (void)definitely_equivalent;
+  VERIFY(definitely_equivalent);
+
+  return definitely_equivalent && definitely_reinterpret_casted && really_empty ? 0 : 1;
+}


More information about the Libstdc++ mailing list