From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1984) id CF61939960D8; Fri, 17 Jul 2020 12:59:01 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org CF61939960D8 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1594990741; bh=qFJuKUHcY0bymU8uxMfeg8DNiv9CTCuCn+VBuV1l9NM=; h=From:To:Subject:Date:From; b=ZNlHRPGT4+qZSYX0rTsj+k/6k9Z0EqR2sbnPUYc00jQKQfXon6jVcOFG8folLTEdh hBdY9+Jj+JUsJUV3Z28JnuAr4wVreV8F3hOraiuyeH9sLF1HhIQEqTPr04VJbAcvL5 A4DoHZRNMWeQwAZD97eAkWwXWLmI6Q4odhZyjOLM= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Tamar Christina To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc(refs/vendors/ARM/heads/arm-struct-reorg-wip)] libstdc++: P1976R2 Fixed-size span construction from dynamic range X-Act-Checkin: gcc X-Git-Author: Jonathan Wakely X-Git-Refname: refs/vendors/ARM/heads/arm-struct-reorg-wip X-Git-Oldrev: d6c9e372372ee78283a21651313fce965d22274d X-Git-Newrev: 9b8e2dea783b3e67813b12c7cb3036b5a9892c65 Message-Id: <20200717125901.CF61939960D8@sourceware.org> Date: Fri, 17 Jul 2020 12:59:01 +0000 (GMT) X-BeenThere: libstdc++-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 17 Jul 2020 12:59:01 -0000 https://gcc.gnu.org/g:9b8e2dea783b3e67813b12c7cb3036b5a9892c65 commit 9b8e2dea783b3e67813b12c7cb3036b5a9892c65 Author: Jonathan Wakely Date: Tue Feb 18 15:51:27 2020 +0000 libstdc++: P1976R2 Fixed-size span construction from dynamic range This includes fixes for first, last, as_bytes and as_writable_bytes which were missing from the paper. * include/std/span (__cpp_lib_span): Update value. (span(It, size_type), span(It, End)): Make conditionally explicit. Add assertion. (span(R&&), span(const span&)): Likewise and relax constraints. (span::first(), span::last()): Use explicit type in return statement. (as_bytes, as_writable_bytes): Likewise. * include/std/version (__cpp_lib_span): Update value. * testsuite/23_containers/span/1.cc: Check new value. * testsuite/23_containers/span/2.cc: Check new value. * testsuite/23_containers/span/explicit.cc: New test. Diff: --- libstdc++-v3/ChangeLog | 14 +++++ libstdc++-v3/include/std/span | 70 ++++++++++++++++------ libstdc++-v3/include/std/version | 2 +- libstdc++-v3/testsuite/23_containers/span/1.cc | 2 +- libstdc++-v3/testsuite/23_containers/span/2.cc | 2 +- .../testsuite/23_containers/span/explicit.cc | 48 +++++++++++++++ 6 files changed, 116 insertions(+), 22 deletions(-) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index de0995264a0..6efae7271b2 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,19 @@ 2020-02-18 Jonathan Wakely + P1976R2 Fixed-size span construction from dynamic range + * include/std/span (__cpp_lib_span): Update value. + (span(It, size_type), span(It, End)): Make conditionally explicit. Add + assertion. + (span(R&&), span(const span&)): Likewise and relax + constraints. + (span::first(), span::last()): Use explicit type in + return statement. + (as_bytes, as_writable_bytes): Likewise. + * include/std/version (__cpp_lib_span): Update value. + * testsuite/23_containers/span/1.cc: Check new value. + * testsuite/23_containers/span/2.cc: Check new value. + * testsuite/23_containers/span/explicit.cc: New test. + * include/std/span (span::__is_compatible_array): Simplify alias template by using requires-clause. (span::__is_compatible_ref): New alias template for constraining diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span index 21114f1e038..a8c69796e5e 100644 --- a/libstdc++-v3/include/std/span +++ b/libstdc++-v3/include/std/span @@ -48,7 +48,7 @@ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION -#define __cpp_lib_span 201902L +#define __cpp_lib_span 202002L inline constexpr size_t dynamic_extent = static_cast(-1); @@ -158,23 +158,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template requires __is_compatible_ref>::value - constexpr + constexpr explicit(extent != dynamic_extent) span(_It __first, size_type __count) noexcept : _M_extent(__count), _M_ptr(std::to_address(__first)) - { __glibcxx_assert(_Extent == dynamic_extent || __count == _Extent); } + { + if constexpr (_Extent != dynamic_extent) + { + __glibcxx_assert(__count == _Extent); + } + } template _End> requires __is_compatible_ref>::value && (!is_convertible_v<_End, size_type>) - constexpr + constexpr explicit(extent != dynamic_extent) span(_It __first, _End __last) noexcept(noexcept(__last - __first)) : _M_extent(static_cast(__last - __first)), _M_ptr(std::to_address(__first)) { - if (_Extent != dynamic_extent) - __glibcxx_assert((__last - __first) == _Extent); + if constexpr (_Extent != dynamic_extent) + { + __glibcxx_assert((__last - __first) == _Extent); + } } template @@ -199,30 +206,41 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } template - requires (_Extent == dynamic_extent) - && ranges::contiguous_range<_Range> && ranges::sized_range<_Range> + requires ranges::contiguous_range<_Range> && ranges::sized_range<_Range> && (ranges::safe_range<_Range> || is_const_v) && (!__detail::__is_std_span>::value) && (!__detail::__is_std_array>::value) && (!is_array_v>) && __is_compatible_ref>::value - constexpr + constexpr explicit(extent != dynamic_extent) span(_Range&& __range) noexcept(noexcept(ranges::data(__range)) && noexcept(ranges::size(__range))) : span(ranges::data(__range), ranges::size(__range)) - { } + { + if constexpr (extent != dynamic_extent) + { + __glibcxx_assert(ranges::size(__range) == extent); + } + } constexpr span(const span&) noexcept = default; template - requires (_Extent == dynamic_extent || _Extent == _OExtent) + requires (_Extent == dynamic_extent || _OExtent == dynamic_extent + || _Extent == _OExtent) && (__is_array_convertible<_Type, _OType>::value) constexpr + explicit(extent != dynamic_extent && _OExtent == dynamic_extent) span(const span<_OType, _OExtent>& __s) noexcept : _M_extent(__s.size()), _M_ptr(__s.data()) - { } + { + if constexpr (extent != dynamic_extent) + { + __glibcxx_assert(__s.size() == extent); + } + } ~span() noexcept = default; @@ -317,7 +335,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_assert(_Count <= size()); else static_assert(_Count <= extent); - return { this->data(), _Count }; + using _Sp = span; + return _Sp{ this->data(), _Count }; } constexpr span @@ -335,7 +354,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_assert(_Count <= size()); else static_assert(_Count <= extent); - return { this->data() + (this->size() - _Count), _Count }; + using _Sp = span; + return _Sp{ this->data() + (this->size() - _Count), _Count }; } constexpr span @@ -351,12 +371,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION -> span()> { if constexpr (_Extent == dynamic_extent) - __glibcxx_assert(_Offset <= size()); + { + __glibcxx_assert(_Offset <= size()); + } else static_assert(_Offset <= extent); + using _Sp = span()>; + if constexpr (_Count == dynamic_extent) - return { this->data() + _Offset, this->size() - _Offset }; + return _Sp{ this->data() + _Offset, this->size() - _Offset }; else { if constexpr (_Extent == dynamic_extent) @@ -369,7 +393,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static_assert(_Count <= extent); static_assert(_Count <= (extent - _Offset)); } - return { this->data() + _Offset, _Count }; + return _Sp{ this->data() + _Offset, _Count }; } } @@ -419,7 +443,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ? dynamic_extent : _Extent * sizeof(_Type)> as_bytes(span<_Type, _Extent> __sp) noexcept { - return {reinterpret_cast(__sp.data()), __sp.size_bytes()}; + auto data = reinterpret_cast(__sp.data()); + auto size = __sp.size_bytes(); + constexpr auto extent = _Extent == dynamic_extent + ? dynamic_extent : _Extent * sizeof(_Type); + return span{data, size}; } template @@ -428,7 +456,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ? dynamic_extent : _Extent * sizeof(_Type)> as_writable_bytes(span<_Type, _Extent> __sp) noexcept { - return {reinterpret_cast(__sp.data()), __sp.size_bytes()}; + auto data = reinterpret_cast(__sp.data()); + auto size = __sp.size_bytes(); + constexpr auto extent = _Extent == dynamic_extent + ? dynamic_extent : _Extent * sizeof(_Type); + return span{data, size}; } namespace ranges diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index f9877ef04ca..b36b999cb31 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -193,7 +193,7 @@ #endif #define __cpp_lib_list_remove_return_type 201806L #define __cpp_lib_math_constants 201907L -#define __cpp_lib_span 201902L +#define __cpp_lib_span 202002L #if __cpp_impl_three_way_comparison >= 201907L && __cpp_lib_concepts # define __cpp_lib_three_way_comparison 201711L #endif diff --git a/libstdc++-v3/testsuite/23_containers/span/1.cc b/libstdc++-v3/testsuite/23_containers/span/1.cc index 7c02aade939..6c622f3e33d 100644 --- a/libstdc++-v3/testsuite/23_containers/span/1.cc +++ b/libstdc++-v3/testsuite/23_containers/span/1.cc @@ -22,6 +22,6 @@ #ifndef __cpp_lib_span # error "Feature-test macro for span missing in " -#elif __cpp_lib_span != 201902L +#elif __cpp_lib_span != 202002L # error "Feature-test macro for span has wrong value in " #endif diff --git a/libstdc++-v3/testsuite/23_containers/span/2.cc b/libstdc++-v3/testsuite/23_containers/span/2.cc index 4a9d1f07325..9e91b5084e0 100644 --- a/libstdc++-v3/testsuite/23_containers/span/2.cc +++ b/libstdc++-v3/testsuite/23_containers/span/2.cc @@ -22,6 +22,6 @@ #ifndef __cpp_lib_span # error "Feature-test macro for span missing in " -#elif __cpp_lib_span != 201902L +#elif __cpp_lib_span != 202002L # error "Feature-test macro for span has wrong value in " #endif diff --git a/libstdc++-v3/testsuite/23_containers/span/explicit.cc b/libstdc++-v3/testsuite/23_containers/span/explicit.cc new file mode 100644 index 00000000000..a763f8045af --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/span/explicit.cc @@ -0,0 +1,48 @@ +// 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 +// . + +// { dg-options "-std=gnu++2a" } +// { dg-do compile { target c++2a } } + +#include + +struct Range +{ + int* begin(); + int* end(); + unsigned size() const; +} r; + +auto first = std::begin(r), last = std::end(r); + +// span(It, size_type) +std::span s1 = {first, 2}; +std::span s2 = {first, 2}; // { dg-error "could not convert" } + +// span(It, End) +std::span s3 = {first, last}; +std::span s4 = {first, last}; // { dg-error "could not convert" } + +// span(R&&) +std::span s5 = r; +std::span s6 = r; // { dg-error "conversion from" } + +// span(const span&) +std::span s7 = s5; +std::span s8 = s6; +std::span s9 = s5.first(1); // { dg-error "conversion from" } +std::span s10 = s7.first(1); // { dg-error "conversion from" }