Skip to content

[simd] Resolve LWG4420 and LWG4393 #8353

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
mattkretz wants to merge 1 commit into from
Closed

[simd] Resolve LWG4420 and LWG4393 #8353

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
121 changes: 71 additions & 50 deletions source/numerics.tex
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16232,6 +16232,12 @@
bool_constant<T() == T::value>::value &&
bool_constant<static_cast<decltype(T::value)>(T()) == T::value>::value;

template<class From, class To>
concept @\defexposconceptnc{explicitly-convertible-to}@ = // \expos
requires {
static_cast<To>(declval<From>());
};

template<class T> using @\exposidnc{deduced-vec-t} = \seebelownc@; // \expos

template<class V, class T> using @\exposidnc{make-compatible-simd-t} = \seebelownc@; // \expos
Expand Down Expand Up @@ -16576,54 +16582,46 @@
flags<Flags...> f = {});

template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
flags<Flags...> f = {});
template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first,
iter_difference_t<I> n, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first,
iter_difference_t<I> n, const typename basic_vec<T, Abi>::mask_type& mask,
flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});

template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
flags<Flags...> f = {});
template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(
const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(
const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});

Expand Down Expand Up @@ -17713,7 +17711,7 @@

\pnum
\constraints
\tcode{value_type} satisfies \tcode{\libconcept{constructible_from}<U>}.
\tcode{U} satisfies \tcode{\exposconcept{explicitly-convertible-to}<value_type>}.

\pnum
\effects
Expand All @@ -17722,10 +17720,11 @@

\pnum
\remarks
The expression inside \tcode{explicit} evaluates to \tcode{false} if and only if
\tcode{U} satisfies \tcode{\libconcept{convertible_to}<value_type>}, and either
The expression inside \tcode{explicit} evaluates to \tcode{false} if and only
if either
\begin{itemize}
\item
\tcode{U} satisfies \tcode{\libconcept{convertible_to}<value_type>} and
\tcode{From} is not an arithmetic type and does not satisfy
\exposconcept{constexpr-wrapper-like},
\item
Expand All @@ -17747,7 +17746,12 @@
\begin{itemdescr}
\pnum
\constraints
\tcode{\exposid{simd-size-v}<U, UAbi> == size()} is \tcode{true}.
\begin{itemize}
\item
\tcode{\exposid{simd-size-v}<U, UAbi> == size()} is \tcode{true}, and
\item
\tcode{U} satisfies \tcode{\exposconcept{explicitly-convertible-to}<T>}.
\end{itemize}

\pnum
\effects
Expand Down Expand Up @@ -17819,20 +17823,17 @@
\begin{itemize}
\item \tcode{R} models \tcode{ranges::\libconcept{contiguous_range}} and
\tcode{ranges::\libconcept{sized_range}},
\item \tcode{ranges::size(r)} is a constant expression, and
\item \tcode{ranges::size(r)} is equal to \tcode{size()}.
\item \tcode{ranges::size(r)} is a constant expression,
\item \tcode{ranges::size(r)} is equal to \tcode{size()}, and
\item \tcode{ranges::range_value_t<R>} is a vectorizable type and satisfies
\tcode{\exposconcept{explicitly-convertible-to}<T>}.
\end{itemize}

\pnum
\mandates
\begin{itemize}
\item
\tcode{ranges::range_value_t<R>} is a vectorizable type, and
\item
if the template parameter pack \tcode{Flags} does not contain
\tcode{\exposid{convert-flag}}, then the conversion from
\tcode{ranges::range_value_t<R>} to \tcode{value_type} is value-preserving.
\end{itemize}
If the template parameter pack \tcode{Flags} does not contain
\tcode{\exposid{convert-flag}}, then the conversion from
\tcode{ranges::range_value_t<R>} to \tcode{value_type} is value-preserving.

\pnum
\expects
Expand Down Expand Up @@ -18575,7 +18576,8 @@
\mandates
\begin{itemize}
\item
\tcode{ranges::range_value_t<R>} is a vectorizable type,
\tcode{ranges::range_value_t<R>} is a vectorizable type and satisfies
\tcode{\exposconcept{explicitly-convertible-to}<T>},
\item
\tcode{same_as<remove_cvref_t<V>, V>} is \tcode{true},
\item
Expand Down Expand Up @@ -18622,26 +18624,22 @@
\indexlibrarymember{unchecked_store}{simd}
\begin{itemdecl}
template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
\end{itemdecl}
Expand Down Expand Up @@ -18688,26 +18686,22 @@
\indexlibrarymember{partial_store}{simd}
\begin{itemdecl}
template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
requires ranges::@\libconcept{sized_range}@<R>
constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
flags<Flags...> f = {});
template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
requires @\libconcept{indirectly_writable}@<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
\end{itemdecl}
Expand All @@ -18725,18 +18719,31 @@
\item
\tcode{r} be \tcode{R(first, n)} for the overloads with an \tcode{n}
parameter and \tcode{R(first, last)} for the overloads with a \tcode{last}
parameter.
parameter;
\item
\tcode{U} be \tcode{ranges::range_value_t<R>}.
\end{itemize}

\pnum
\constraints
\begin{itemize}
\item
\tcode{ranges::iterator_t<R>} satisfies
\tcode{\libconcept{indirectly_writable}<U>}, and
\item
\tcode{T} satisfies
\tcode{\exposconcept{explicitly-convertible-to}<U>}.
\end{itemize}

\pnum
\mandates
\begin{itemize}
\item
\tcode{ranges::range_value_t<R>} is a vectorizable type, and
\tcode{U} is a vectorizable type, and
\item
if the template parameter pack \tcode{Flags} does not contain
\tcode{\exposid{convert-flag}}, then the conversion from \tcode{T} to
\tcode{ranges::range_value_t<R>} is value-preserving.
\tcode{U} is value-preserving.
\end{itemize}

\pnum
Expand All @@ -18751,8 +18758,7 @@
\item
If the template parameter pack \tcode{Flags} contains
\tcode{\exposid{aligned-flag}}, \tcode{ranges::data(r)} points to storage
aligned by \tcode{alignment_v<basic_vec<T, Abi>,
ranges::range_value_t<R>>}.
aligned by \tcode{alignment_v<basic_vec<T, Abi>, U>}.
\item
If the template parameter pack \tcode{Flags} contains
\tcode{\exposid{overaligned-flag}<N>}, \tcode{ranges::data(r)} points to
Expand All @@ -18763,7 +18769,7 @@
\effects
For all $i$ in the range of \range{0}{basic_vec<T, Abi>::size()}, if
\tcode{mask[$i$] \&\& $i$ < ranges::\brk{}size(r)} is \tcode{true}, evaluates
\tcode{ranges::data(r)[$i$] = v[$i$]}.
\tcode{ranges::data(r)[$i$] = static_cast<U>(v[$i$])}.
\end{itemdescr}

\rSec3[simd.permute.static]{Static permute}
Expand Down Expand Up @@ -18995,6 +19001,11 @@
\tcode{T} be \tcode{typename V::value_type}.
\end{itemize}

\pnum
\constraints
\tcode{ranges::range_value_t<R>} is a vectorizable type and satisfies
\tcode{\exposconceptx{explicitly-con\-vert\-ible-to}{explicitly-convertible-to}<T>}.

\pnum
\mandates
\begin{itemize}
Expand Down Expand Up @@ -19083,20 +19094,30 @@
\pnum
Let \tcode{mask} be \tcode{typename I::mask_type(true)} for the overload with
no \tcode{mask} parameter.
Let \tcode{U} be \tcode{ranges::range_value_t<R>}.

\pnum
\constraints
\tcode{V::size() == I::size()} is \tcode{true}.
\begin{itemize}
\item
\tcode{V::size() == I::size()} is \tcode{true},
\item
\tcode{ranges::iterator_t<R>} satisfies
\tcode{\libconcept{indirectly_writable}<U>}, and
\item
\tcode{typename V::value_type} satisfies
\tcode{\exposconcept{explicitly-convertible-to}<U>}.
\end{itemize}

\pnum
\mandates
\begin{itemize}
\item
\tcode{ranges::range_value_t<R>} is a vectorizable type, and
\tcode{U} is a vectorizable type, and
\item
if the template parameter pack \tcode{Flags} does not contain \exposid{convert-flag},
then the conversion from \tcode{typename V::value_type}
to \tcode{ranges::range_value_t<R>} is value-preserving.
then the conversion from \tcode{typename V::value_type} to \tcode{U} is
value-preserving.
\end{itemize}

\pnum
Expand All @@ -19107,7 +19128,7 @@
\item
If the template parameter pack \tcode{Flags} contains \exposid{aligned-flag},
\tcode{ranges::data(out)} points to storage aligned by
\tcode{alignment_v<V, ranges::range_value_t<R>>}.
\tcode{alignment_v<V, U>}.
\item
If the template parameter pack \tcode{Flags} contains
\tcode{\exposid{overaligned-flag}<N>},
Expand Down