[libcxx] <experimental/simd> Add ABI tags, class template simd/simd_mask implementations. Add related simd traits and tests.

[Joy12138]

Summary

[libcxx] <experimental/simd> Add ABI tags, class template simd/simd_mask implementations.
[libcxx] <experimental/simd> Add traits is_abi_tag[_v], is_simd[_v] and is_simd_mask[_v].
[libcxx] <experimental/simd> Add related tests.

[philnik]

In D144362#4141213, @Joy12138 wrote:

@philnik @Mordante Thanks for your attention to this patch. I don't know how to reply to you all in the comment, so I wrote all replies here.

Thanks for working on this. Is N4808 voted in? I can only find a draft version.

It seems it is still draft. Should I continue to refer to this document, or which other version?

Why do you remove all of the old implementation? Is it so radically different from what you want to implement?

I'm wondering the same. Normally we don't remove code, since it may break existing users.
However I think our current implementation is so minimal that risk isn't too great.

Yes, although we referred to and followed the original implementation, we have made great adjustments to the overall implementation framework and test framework.

Implementation framework:

Now we use the internal ABI as a template parameter. And we use the template class simd_storage/mask_storage to define the storage type of the internal ABI, use the template class simd_traits/mask_traits to implement operations of the internal ABI. We put these template specializations of each internal ABI in a seperate header file. We believe that this will help to expand the internal ABI and to make target-specific optimizations in the future.

Test framework:

We also reconstructed the test code structure. Added a test framework to improve test coverage. Because most external user interfaces are related to class simd/simd_mask, we have traversed all possible data types and ABI tags combinations of class simd/simd_mask in related interface tests.

We have now completed the implementation of a stable version (Refer to this revision: https://reviews.llvm.org/D139421). This stable version included all external user interfaces except the Math Library. And added corresponding external interfaces tests. I hope that the code finally submitted to the upstream will be closer to the current available implementation. So it may be hard to advance on the original implementation. I prefer to remove the original implementation and build our existing framework from the most basic part. I plan to submit the follow-up implementation step by step In the next two months to completely cover all interfaces. I suggest we can consider to land all these patches together after they are reviewed and approved to avoid breaking existing users.

The synopsis should be updated as we go, to show what has actually been implemented. I am aware that this isn't the case currently, so let's fix this.

Let's keep the stable names. Section numbers are just a nightmare to maintain and will be wrong. At least they are everywhere they are used currently.

+1 Especially since these numbers will change if this is adopted on the Standard. Using the stable names gives a higher probability these references remain valid.

Could you remove all the declaration-only stuff in a separate PR? We normally don't have the interface declared if it's not defined.

Summary (correct me if I misunderstood):

1. No declarations.
2. Give synopsis of implemented interfaces only.
3. Keep original stable names of sections without section numbers.

Yes, that's essentially it. I would suggest a patch that just removes everything from the header and the tests and then have a stack that re-implements the already-implemented stuff. Then the stack can be landed together. I think it would make sense to not implementing anything new in this stack between removing the implementation and having everything that is already implemented again, so it's essentially just a bunch of refactoring. On top of that we can them implement more of the interface. Looking at our current implementation, there is not that much implemented, so I guess the stack shouldn't be that large.

libcxx/include/experimental/__simd/scalar.h

16

Yes, it's the more typical way, but AFAICT mostly for symmetry with _LIBCPP_BEGIN_NAMESPACE_STD. There it makes a lot more sense IMO, since that namespace actually changes depending on the configuration. That's not the case for experimental stuff. We also don't have _LIBCPP_BEGIN_NAMESPACE_STD_RANGES/FORMAT/etc..

[Mordante]

In D144362#4141213, @Joy12138 wrote:

@philnik @Mordante Thanks for your attention to this patch. I don't know how to reply to you all in the comment, so I wrote all replies here.

Thanks for working on this. Is N4808 voted in? I can only find a draft version.

It seems it is still draft. Should I continue to refer to this document, or which other version?

Ideally you would use ISO/IEC TS 19570:2018 which is the real Standard. Based on the editor's report N4809 [1] there should be no normative changes between the Standard and this document.

[1] https://github.com/cplusplus/parallelism-ts/releases

[ldionne]

Thanks for working on this! Incidentally, I recently received a report that our simd implementation was broken in all sorts of way, and it's great to get it sorted out.

libcxx/include/experimental/__simd/scalar.h

16

Is there any reason for not doing (formatted however you prefer):

_LIBCPP_BEGIN_NAMESPACE_STD
namespace experimental { inline namespace parallelism_v2 {
  ....
}}
_LIBCPP_END_NAMESPACE_STD

? Then we could get rid of _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI altogether.

libcxx/include/experimental/simd

225

I would like to guard this whole header under _LIBCPP_ENABLE_EXPERIMENTAL. Users should use -fexperimental-library to be able to use the TSes.

[philnik]

libcxx/include/experimental/__simd/scalar.h

16

That was basically the idea, just that I wouldn't bother with the versioned namespace, since it's unstable anyways.

[Joy12138]

Update the revision. Now it is a child revision of D144698. It includes following stuff:

[libcxx] <experimental/simd> Add ABI tags, class template simd/simd_mask implementations.
[libcxx] <experimental/simd> Add traits is_abi_tag[_v], is_simd[_v] and is_simd_mask[_v].
[libcxx] <experimental/simd> Add related tests.

[Joy12138]

Fix namespace issue

[Joy12138]

Fix transitive includes issue

[philnik]

libcxx/include/CMakeLists.txt

784

I think it would be good to add a status paper, so it's easier to see what it already implemented and what you want to implement in a particular patch. I'd be fine with just having the big groups in it for now and split them up as we implement more. You can look at libcxx/docs/Status/Zip{.rst,Projects.csv} for an example.
This should be a good start:

Section,Description,Dependencies,Assignee,Complete
| [parallel.exceptions], "Parallel Exceptions", None, unassigned, |Not Started|
| [parallel.execpol], "Execution policies", None, unassigned, |Not Started|
| [parallel.alg], "Parallel algorithms", None, unassigned, |Not Started|
| [parallel.taskblock], "Task Block", None, unassigned, |Not Started|
| [parallel.simd.abi], "simd ABI tags", None, unassigned, |Not Started|
| [parallel.simd.traits], "simd type traits", None, unassigned, |Not Started|
| [parallel.simd.whereexpr], "Where expression class templates", None, unassigned, |Not Started|
| [parallel.simd.class], "Class template simd", None, unassigned, |Not Started|
| [parallel.simd.nonmembers], "simd non-member operations", None, unassigned, |Not Started|
| [parallel.simd.mask.class], "Reductions", None, unassigned, |Not Started|
| [parallel.simd.mask.nonmembers], "Non-member operations", None, unassigned, |Not Started|

libcxx/include/experimental/simd

234–235

Please use the granularized headers.

243

Since this is all new code, please clang-format the whole file.

libcxx/test/std/experimental/simd/test_utils.h

38–53

We have libcxx/test/support/type_algorithms.h to help with this kind of stuff.

[Joy12138]

libcxx/include/CMakeLists.txt

784

I added the status paper in D145652. I'm not sure if the naming and format are appropriate. Please help to review, thank you.

[Joy12138]

Replace includes with granularized headers.

Update status paper.

[Joy12138]

libcxx/include/experimental/simd

243

I tried git clang-format HEAD~1 and it said clang-format did not modify any files.

Is there anything in this file that does not conform to the LLVM/libcxx Coding Standards?

[philnik]

Please mark comments you have addressed as "Done" to make it easier to see what you have already worked on.

libcxx/include/experimental/simd

243

git clang-format doesn't know this file is supposed to be formatted, since it doesn't have a file extension. You can (and should) remove libcxx/include/experimental/simd from libcxx/utils/data/ignore_format.txt. The CI then shows you what has to be formatted. It should also be possible to do clang-format libcxx/include/experimental/simd. That way clang-format knows that it's supposed to format this file.

246–250

I think we should define the aliases in the headers where the actual tags are.

249

This seems like something that might change from platform to platform. Could you add a TODO: make this platform dependent?

260–268

These should probably get their own headers. I guess the classes are not super small.

271–274

I think it would be easier to move this to it's own header, and then specialize is_abi_tag per ABI tag, i.e.

// traits.h
template <class _Tp>
inline constexpr bool is_abi_tag_v = false;

template <class _Tp>
struct is_abi_tag : bool_constant<is_abi_tag_v<_Tp>> {};

// scalar.h
template <>
inline constexpr bool is_abi_tag_v<__scalar> = true;

// vec_ext.h
template <int _Np>
inline constexpr bool is_abi_tag_v<__vec_ext<_Np>> = true;

Note that this also implements is_abi_tag in terms of is_abi_tag_v and not the other way around. Most people just use the latter, so we should avoid instantiating a class every time. This part also applies to is_simd and is_simd_mask.

[Joy12138]

libcxx/include/experimental/simd

260–268

In our design of the SIMD library structure, these specializations of the simd/simd_mask will not have their own headers. This is because the implementations are not divided by the ABI tags of the user interface layer, but by the internal ABI tags. These internal tags do not correspond one-to-one with the user interface layer tags.

Let me briefly introduce the current structure design:

We divide the structure into three layers, with the specific implementations in the second and third layers. Each layer uses the ABI tags corresponding to that layer for template specialization.

The first layer is the external user interface layer, which corresponds to the external ABI tags given in the specification, such as scalar, native, compatible, and fixed_size.

The second layer is the common internal implementation layer, which is platform-independent. This layer corresponds to the internal ABI tags __scalar and __vec_ext. The implementation of the __vec_ext ABI tag uses Clang vector extensions (GCC builtins) as the storage type and Clang vector operators and built-ins to implement vector operations. We have tested this on various platforms and confirmed that the implementation of __vec_ext can correctly generate SIMD instructions supported by the current platform. We believe this will be a common solution for all platforms and will also serve as a fallback when the platform does not support SIMD.

The third layer is the platform-dependent optimization layer. Since the common layer implementation can correctly generate SIMD instructions, we only need to use some unique platform features or instructions to optimize parts of the implementation with poor performance on the common layer. This work has not yet started, and we may use some platform-specific internal ABI tags such as __AVX, __NEON, etc. at that time.

Therefore,

[Joy12138]

libcxx/include/experimental/simd

249

This seems like something that might change from platform to platform. Could you add a TODO: make this platform dependent?

These tags will not be platform dependent until the third layer work is started.

260–268

These should probably get their own headers. I guess the classes are not super small.

These specializations has no direct corresponding implementation. In the current implementation, they all indirectly correspond to __vec_ext, but this may also change in the future due to changes of ABI tags. So it seems inappropriate to put them all in vec_ext. h.

[Joy12138]

libcxx/include/experimental/simd

271–274

This looks great, but there are often references to other interfaces in the implementation of traits. If traits are to be implemented in different ABI tag headers, we may need to add some declarations to the outer layer of these headers. For example, class simd/simd_mask will be referenced in the is_simd/is_simd_mask implementation. Should I use a new header (declaration. h) to add these declarations?

[Joy12138]

Fix clang format

[Joy12138]

Adjust headers inclusion

[Joy12138]

Rebase

[Joy12138]

Fix rebase error

[Joy12138]

Update test structure with type_algorithms.h

[Joy12138]

try cxx03

[Joy12138]

Move traits to separate headers.

[Joy12138]

Reorder includes

[Joy12138]

Fix CI

[Joy12138]

Fix CI

[Joy12138]

Fix CI

[Joy12138]

Fix C++17

[Joy12138]

@philnik Hi! I have resolved most of the comments and marked them as done. Comments that have not yet been marked may require further discussion.

Do you have any other comments? If not, I will continue to organize and submit the remaining content based on this patch. That may also contribute to the discussion of the overall framework.

By the way, does CI need to be fixed? CI errors do not seem to be introduced by this patch.

[philnik]

In D144362#4277646, @Joy12138 wrote:

@philnik Hi! I have resolved most of the comments and marked them as done. Comments that have not yet been marked may require further discussion.

Do you have any other comments? If not, I will continue to organize and submit the remaining content based on this patch. That may also contribute to the discussion of the overall framework.

By the way, does CI need to be fixed? CI errors do not seem to be introduced by this patch.

The CI problems are unrelated.

libcxx/include/experimental/__simd/declarations.h

15–23 ↗

(On Diff #513524)

There can be a few more newlines throughout.

libcxx/include/experimental/simd

249

Then I'd like a TODO for this, just in case someone else continues the work.

260–268

Moving them into separate headers is for ease of maintenance and avoiding transitively including too many symbols.

271–274

You just specialize the traits in the header where the class is defined. No need to forward-declare anything.

[Joy12138]

libcxx/include/experimental/simd

271–274

Sorry, my previous description was not clear enough. The main issue is that in our design, for more code reuse and more flexible use of internal interfaces, the structure of the external interface layer and internal implementation layer is not consistent. And template specialization does not directly occur on external interfaces such as simd/simd_mask classes.

We have designed four modules, SIMD/MASK storage type and SIMD/MASK operations, for different ABI tags at the implementation layer, which will be used by various external interfaces, including simd/simd_mask, where_expression and non-member functions.

i.e.

// simd
template <class _Tp, class _Abi>
class simd {
  using _Impl    = __simd_operations<_Tp, _Abi>;
  using _Storage = __simd_storage<_Tp, _Abi>;
  
  _Storage __s_;
  
  simd operator+(const simd& __lhs, const simd& __rhs) {
    return _Impl::__plus(__lhs.__s_, __rhs.__s_);
  }
}

// scalar.h
template <class _Tp>
struct __simd_storage<_Tp, simd_abi::__scalar> {
	......
};

template <class _Tp>
struct __simd_operations<_Tp, simd_abi::__scalar> {
	......
};

// vec_ext.h
template <class _Tp, int _Np>
struct __simd_storage<_Tp, simd_abi::__vec_ext<_Np>> {
	......
};

template <class _Tp, int _Np>
struct __simd_operations<_Tp, simd_abi::__vec_ext<_Np>> {
	......
};

Since the specialization does not occur on external interfaces, the external interfaces is now directly placed in the simd header. if the implementation of simd traits is to be placed in a separate header, a forward declaration is required, and if it is placed together with the external interfaces, it will also be placed in the simd header.

Do you have any better suggestions for the current code structure?

[Joy12138]

libcxx/include/experimental/simd

271–274

In addition, most simd traits are platform independent, is it not necessary to specialize for all traits?

[Joy12138]

Add newlines and TODOs.

[Joy12138]

This comment was removed by Joy12138.

[Joy12138]

@philnik Just ping for the above discussion.

[philnik]

libcxx/include/experimental/simd

271–274

I'm a bit confused what exactly you are talking about. Was this meant for a different thread?

[Joy12138]

libcxx/include/experimental/simd

271–274

I'm sorry my description confused you. Maybe I shouldn't have put this content in this thread. I just want to discuss the overall structure and the use of template specialization. And they have some impact on the implementation of simd traits.

What I mainly want to express is that since we do not directly specialize templates on external user interfaces, there will not be directly definitions and implementations of such as
simd<_Tp, __vec_ext<_Np>>. It is basically composed of simd_storage<_Tp, __vec_ext<_Np>> and simd_operations<_Tp, __vec_ext<_Np>>. So we cannot directly define is_simd<simd<_Tp, __vec_ext<_Np>>> without forward-declare of simd class.

[philnik]

LGTM % nits. (and sorry for being so slow in reviewing this)

libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp

55

56

Couldn't the static_asserts be inlined here? The CheckIsAbiTag* could simply be tag types.

libcxx/test/std/experimental/simd/test_utils.h

36

This doesn't really seem with it given that it already just ex.

[Joy12138]

Fix test

[Joy12138]

@philnik Hi! We rewrite the tests. Please review it again. Thank you!

[philnik]

The updated tests look really nice! Thanks!

You probably have to rebase on top of main to make the CI happy.

libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp

30–38

clang-format will be happy with this.

libcxx/test/std/experimental/simd/test_utils.h

21–22

This is just integer_types, right?

[Joy12138]

Fix test format

[Joy12138]

libcxx/test/std/experimental/simd/test_utils.h

21–22

No, it is not the same.

The first template parameter of the simd class does not accept input of bool type. And the vector type corresponding to bool type is defined by simd_mask class.

In "type_algorithms.h", integer_types has the following definition:

// libcxx/test/support/type_algorithms.h:98
using integral_types = concatenate_t<character_types, signed_integer_types, unsigned_integer_types, type_list<bool> >;

It contains type bool. And we need arithmetic types without bool to test class simd.

[Joy12138]

I encountered a problem in subsequent development that currently seems to need to be resolved in this patch.

In the previous comment, you suggested that I place all simd traits in a separate header file traits.h. During the process of adding the rest traits implementations, I found that most of them require the use of other interfaces placed in the simd header, similar to is_simd requires the use of simd classes. Therefore, I added declaration.h as forward declarations. However, there are too many interfaces that need to be referenced in the future, which is not suitable to add forward declarations for all.

I think there are two solutions.
One is to keep all external user interfaces under the simd header, just like our previous implementation.
Another is to categorize all external user interfaces into separate header files. No implementations in the simd header and only including other header files in order. Then we may need to add traits.h, simd.h, simd_mask.h, aligned_tag.h, abi_tag.h, simd_casts.h, where_expression.h, etc.
Which one do you prefer?

[philnik]

In D144362#4389779, @Joy12138 wrote:

I encountered a problem in subsequent development that currently seems to need to be resolved in this patch.

In the previous comment, you suggested that I place all simd traits in a separate header file traits.h. During the process of adding the rest traits implementations, I found that most of them require the use of other interfaces placed in the simd header, similar to is_simd requires the use of simd classes. Therefore, I added declaration.h as forward declarations. However, there are too many interfaces that need to be referenced in the future, which is not suitable to add forward declarations for all.

I think there are two solutions.
One is to keep all external user interfaces under the simd header, just like our previous implementation.
Another is to categorize all external user interfaces into separate header files. No implementations in the simd header and only including other header files in order. Then we may need to add traits.h, simd.h, simd_mask.h, aligned_tag.h, abi_tag.h, simd_casts.h, where_expression.h, etc.
Which one do you prefer?

I think it's easier to gollow the code when splitting up the headers, so I'd go for option 2.

libcxx/test/std/experimental/simd/test_utils.h

21–22

You show the implementation of integral_types, not integer_types ;-)

[Joy12138]

Rebase, and reorganize file structure

[Joy12138]

Use integer_types in test_utils.h

[Joy12138]

Fix clang format

[Joy12138]

Fix transitive includes in cxx26

[Joy12138]

Fix order in CMakeList

[Joy12138]

Fix transitive includes in cxx03 and cxx11

[Joy12138]

Fix transitive includes in cxx14

[Joy12138]

Fix transitive includes in cxx23

[Joy12138]

@philnik Hi! Could you please help me check the CI errors?

Last time it prompted me to remove the following statement in transitive includes of cxx23 and cxx26.

*** 174,179 ****

--- 174,180 ----

  experimental/regexregex

  experimental/setexperimental/memory_resource

  experimental/setset

- experimental/simdcstddef

  experimental/stringexperimental/memory_resource

  experimental/stringstring

  experimental/type_traitsinitializer_list



error: command failed with exit status: 1

But this time after I removed, it prompted me to add.

*** 174,179 ****

--- 174,180 ----

  experimental/regexregex

  experimental/setexperimental/memory_resource

  experimental/setset

+ experimental/simdcstddef

  experimental/stringexperimental/memory_resource

  experimental/stringstring

  experimental/type_traitsinitializer_list



error: command failed with exit status: 1

[philnik]

In D144362#4402252, @Joy12138 wrote:

@philnik Hi! Could you please help me check the CI errors?

Last time it prompted me to remove the following statement in transitive includes of cxx23 and cxx26.

*** 174,179 ****

--- 174,180 ----

  experimental/regexregex

  experimental/setexperimental/memory_resource

  experimental/setset

- experimental/simdcstddef

  experimental/stringexperimental/memory_resource

  experimental/stringstring

  experimental/type_traitsinitializer_list



error: command failed with exit status: 1

But this time after I removed, it prompted me to add.

*** 174,179 ****

--- 174,180 ----

  experimental/regexregex

  experimental/setexperimental/memory_resource

  experimental/setset

+ experimental/simdcstddef

  experimental/stringexperimental/memory_resource

  experimental/stringstring

  experimental/type_traitsinitializer_list



error: command failed with exit status: 1

It looks to me like adding it is the correct thing. Do you know which bot didn't like the added line?

[Joy12138]

Add transitive includes in cxx23

[Joy12138]

@philnik I added it again, you can see the current CI errors.

[philnik]

libcxx/include/experimental/simd

676

This check should be done after including the detail headers.

[Joy12138]

Fix CI errors

[Joy12138]

Fix clang format

[Joy12138]

Fix transitive includes in cxx03 and cxx11

[Joy12138]

Fix transitive includes in cxx14

[Joy12138]

@philnik CIs have passed. Do you have any other comments?

[philnik]

In D144362#4413844, @Joy12138 wrote:

@philnik CIs have passed. Do you have any other comments?

Nope, LGTM.

[philnik]

libcxx/test/std/experimental/simd/test_utils.h

23

These shouldn't be _Uglified, since they are part of the test code.

33

This makes this part a bit more complex, but the recursion inside the tests isn't there anymore, making them quite a bit simpler.

36

It doesn't look like the F argument is ever used. Why did you add it?

40–42

[philnik]

I've applied for patch locally and reworked the instantiation logic a bit. This is my solution:

test_utils.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef TEST_UTIL_H
#define TEST_UTIL_H

#include <utility>
#include <experimental/simd>
#include "type_algorithms.h"

namespace ex = std::experimental::parallelism_v2;

constexpr std::size_t max_simd_size = 32;

template <template <std::size_t N> class F>
struct TestAllSimdAbiFunctor {
  template <class T, std::size_t N>
  using sized_abis = types::type_list<ex::simd_abi::fixed_size<N>, ex::simd_abi::deduce_t<T, N>>;

  template <class T, std::size_t... Ns>
  void instantiate_with_n(std::index_sequence<Ns...>) {
    (types::for_each(sized_abis<T, Ns + 1>{}, F<Ns + 1>{}), ...);
  }

  template <class T>
  void operator()() {
    using abis = types::type_list<ex::simd_abi::scalar, ex::simd_abi::native<T>, ex::simd_abi::compatible<T>>;
    types::for_each(abis{}, F<1>());

    instantiate_with_n<T>(std::make_index_sequence<max_simd_size - 1>{});
  }
};

template <template <std::size_t N> class Func>
void test_all_simd_abi() {
  using arithmetic_no_bool_types = types::concatenate_t<types::integer_types, types::floating_point_types>;
  types::for_each(arithmetic_no_bool_types(), TestAllSimdAbiFunctor<Func>());
}

#endif // TEST_UTIL_H

is_abi_tag.pass.cpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11, c++14

// <experimental/simd>
//
// [simd.traits]
// template <class T> struct is_abi_tag;
// template <class T> inline constexpr bool ex::is_abi_tag_v = ex::is_abi_tag<T>::value;

#include "../test_utils.h"
#include <experimental/simd>

namespace ex = std::experimental::parallelism_v2;

class EmptyEntry {};

template <std::size_t N>
struct Test {
  template <class SimdAbi>
  void operator()() {
    static_assert(ex::is_abi_tag<SimdAbi>::value);

    static_assert(!ex::is_abi_tag<EmptyEntry>::value);
    static_assert(!ex::is_abi_tag<ex::simd< EmptyEntry, SimdAbi>>::value);
    static_assert(!ex::is_abi_tag<ex::simd_mask< EmptyEntry, SimdAbi>>::value);

    static_assert(ex::is_abi_tag_v<SimdAbi>);

    static_assert(!ex::is_abi_tag_v<EmptyEntry>);
    static_assert(!ex::is_abi_tag_v<ex::simd< EmptyEntry, SimdAbi>>);
    static_assert(!ex::is_abi_tag_v<ex::simd_mask< EmptyEntry, SimdAbi>>);
  }
};

int main(int, char**) {
  test_all_simd_abi<Test>();
  return 0;
}

I think this version is quite a bit easier to follow. WDYT?

[Joy12138]

In D144362#4445885, @philnik wrote:

I've applied for patch locally and reworked the instantiation logic a bit. This is my solution:

test_utils.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef TEST_UTIL_H
#define TEST_UTIL_H

#include <utility>
#include <experimental/simd>
#include "type_algorithms.h"

namespace ex = std::experimental::parallelism_v2;

constexpr std::size_t max_simd_size = 32;

template <template <std::size_t N> class F>
struct TestAllSimdAbiFunctor {
  template <class T, std::size_t N>
  using sized_abis = types::type_list<ex::simd_abi::fixed_size<N>, ex::simd_abi::deduce_t<T, N>>;

  template <class T, std::size_t... Ns>
  void instantiate_with_n(std::index_sequence<Ns...>) {
    (types::for_each(sized_abis<T, Ns + 1>{}, F<Ns + 1>{}), ...);
  }

  template <class T>
  void operator()() {
    using abis = types::type_list<ex::simd_abi::scalar, ex::simd_abi::native<T>, ex::simd_abi::compatible<T>>;
    types::for_each(abis{}, F<1>());

    instantiate_with_n<T>(std::make_index_sequence<max_simd_size - 1>{});
  }
};

template <template <std::size_t N> class Func>
void test_all_simd_abi() {
  using arithmetic_no_bool_types = types::concatenate_t<types::integer_types, types::floating_point_types>;
  types::for_each(arithmetic_no_bool_types(), TestAllSimdAbiFunctor<Func>());
}

#endif // TEST_UTIL_H

is_abi_tag.pass.cpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11, c++14

// <experimental/simd>
//
// [simd.traits]
// template <class T> struct is_abi_tag;
// template <class T> inline constexpr bool ex::is_abi_tag_v = ex::is_abi_tag<T>::value;

#include "../test_utils.h"
#include <experimental/simd>

namespace ex = std::experimental::parallelism_v2;

class EmptyEntry {};

template <std::size_t N>
struct Test {
  template <class SimdAbi>
  void operator()() {
    static_assert(ex::is_abi_tag<SimdAbi>::value);

    static_assert(!ex::is_abi_tag<EmptyEntry>::value);
    static_assert(!ex::is_abi_tag<ex::simd< EmptyEntry, SimdAbi>>::value);
    static_assert(!ex::is_abi_tag<ex::simd_mask< EmptyEntry, SimdAbi>>::value);

    static_assert(ex::is_abi_tag_v<SimdAbi>);

    static_assert(!ex::is_abi_tag_v<EmptyEntry>);
    static_assert(!ex::is_abi_tag_v<ex::simd< EmptyEntry, SimdAbi>>);
    static_assert(!ex::is_abi_tag_v<ex::simd_mask< EmptyEntry, SimdAbi>>);
  }
};

int main(int, char**) {
  test_all_simd_abi<Test>();
  return 0;
}

I think this version is quite a bit easier to follow. WDYT?

The solution looks great. It works well overall, but there's one aspect I believe could be improved. Since a basic simd need type and simdabi 2 factors, type will usually be used in most of the test functors. I intend to pass the type to F.

For clarity, I've made a comparison of the codes which you can review at the following link: https://www.diffchecker.com/2ja2Qq7t/

[philnik]

In D144362#4446950, @Joy12138 wrote:

The solution looks great. It works well overall, but there's one aspect I believe could be improved. Since a basic simd need type and simdabi 2 factors, type will usually be used in most of the test functors. I intend to pass the type to F.

For clarity, I've made a comparison of the codes which you can review at the following link: https://www.diffchecker.com/2ja2Qq7t/

Sounds good to me.

[Joy12138]

Rewrite test

[Joy12138]

Add newline at end of file

[Joy12138]

Rebase

[Joy12138]

Rebase

[Joy12138]

Rebase

[Joy12138]

Fix template variable style

[Joy12138]

Rebase

libcxx/include/CMakeLists.txt

set(files
   cstdio
   cstdlib
   cstring
   ctgmath
   ctime
   ctype.h
   cuchar
   cwchar
   cwctype
   deque
   errno.h
   exception
   execution
   expected
   experimental/__config
   experimental/__memory
+  experimental/__simd/scalar.h
+  experimental/__simd/utility.h
+  experimental/__simd/vec_ext.h
   experimental/algorithm
   experimental/deque
   experimental/forward_list
   experimental/functional
   experimental/iterator
   experimental/list
   experimental/map
   experimental/memory_resource

libcxx/include/experimental/__simd/scalar.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H
+
+#include <cstddef>
+#include <experimental/__config>
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
+
+struct __scalar {
+  static constexpr bool __is_abi_tag  = true;
+  static constexpr size_t __simd_size = 1;
+};
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
+
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H

libcxx/include/experimental/__simd/utility.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
+
+#include <cstdint>
+#include <experimental/__config>
+#include <tuple>
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
+
+class _Bool {
+  const bool __v;
+
+public:
+  constexpr _Bool(bool __b) : __v(__b) {}
+  _Bool(int) = delete;
+  constexpr operator bool() const { return __v; }
+};
+
+template <class _To, class _From>
+constexpr decltype(_To{declval<_From>()}, true) __is_non_narrowing_convertible_impl(_From) {
+  return true;
+}
+
+template <class _To>
+constexpr bool __is_non_narrowing_convertible_impl(...) {
+  return false;
+}
+
+template <class _From, class _To>
+constexpr bool __is_non_narrowing_arithmetic_convertible() {
+  if constexpr (is_arithmetic_v<_To> && is_arithmetic_v<_From>)
+    return __is_non_narrowing_convertible_impl<_To>(_From{});
+  else
+    return false;
+}
+
+template <class _Tp, class... _Args>
+constexpr _Tp __variadic_sum(_Args... __args) {
+  return (static_cast<_Tp>(__args) + ...);
+}
+
+template <class _Tp>
+constexpr bool __is_vectorizable() {
+  return is_arithmetic_v<_Tp> && !is_const_v<_Tp> && !is_volatile_v<_Tp> && !is_same_v<_Tp, bool>;
+}
+
+template <class _Tp, class _Up>
+constexpr bool __can_broadcast() {
+  return (is_arithmetic_v<_Up> && __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) ||
+         (!is_arithmetic_v<_Up> && is_convertible_v<_Up, _Tp>) || is_same_v<remove_const_t<_Up>, int> ||
+         (is_same_v<remove_const_t<_Up>, unsigned int> && is_unsigned_v<_Tp>);
+}
+
+template <class _Tp, class _Generator, size_t... __indicies>
+constexpr decltype(forward_as_tuple(declval<_Generator>()(integral_constant<size_t, __indicies>())...), bool())
+__can_generate(index_sequence<__indicies...>) {
+  return !__variadic_sum<bool>(
+      !__can_broadcast<_Tp, decltype(declval<_Generator>()(integral_constant<size_t, __indicies>()))>()...);
+}
+
+template <class _Tp, class _Generator>
+bool __can_generate(...) {
+  return false;
+}
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
+
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H

libcxx/include/experimental/__simd/vec_ext.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H
+
+#include <cstddef>
+#include <experimental/__config>
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
+
+template <int _Np>
+struct __vec_ext {
+  static constexpr bool __is_abi_tag  = _Np > 0 && _Np <= 32;
+  static constexpr size_t __simd_size = _Np;
+};
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
+
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H

libcxx/include/experimental/simd

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_EXPERIMENTAL_SIMD
 #define _LIBCPP_EXPERIMENTAL_SIMD
 
+#define __cpp_lib_experimental_parallel_simd 201803
+
 /*
     experimental/simd synopsis
 
 namespace std::experimental {
-
 inline namespace parallelism_v2 {
-
   namespace simd_abi {
-
-struct scalar {};
-template <int N> struct fixed_size {};
-template <typename T> inline constexpr int max_fixed_size = implementation-defined;
-template <typename T> using compatible = implementation-defined;
-template <typename T> using native = implementation-defined;
-
-} // simd_abi
+    using scalar = see below;
+    template<int N> using fixed_size = see below;
+    template<class T> inline constexpr int max_fixed_size = implementation-defined;
+    template<class T> using compatible = implementation-defined;
+    template<class T> using native = implementation-defined;
+
+    template<class T, size_t N, class... Abis> struct deduce { using type = see below; };
+    template<class T, size_t N, class... Abis> using deduce_t =
+      typename deduce<T, N, Abis...>::type;
+  }
 
   struct element_aligned_tag {};
   struct vector_aligned_tag {};
-template <size_t> struct overaligned_tag {};
+  template<size_t> struct overaligned_tag {};
   inline constexpr element_aligned_tag element_aligned{};
   inline constexpr vector_aligned_tag vector_aligned{};
-template <size_t N> inline constexpr overaligned_tag<N> overaligned{};
+  template<size_t N> inline constexpr overaligned_tag<N> overaligned{};
 
-// traits [simd.traits]
-template <class T> struct is_abi_tag;
-template <class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;
+  // 9.4, simd type traits
+  template<class T> struct is_abi_tag;
+  template<class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;
 
-template <class T> struct is_simd;
-template <class T> inline constexpr bool is_simd_v = is_simd<T>::value;
+  template<class T> struct is_simd;
+  template<class T> inline constexpr bool is_simd_v = is_simd<T>::value
 
-template <class T> struct is_simd_mask;
-template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;
+  template<class T> struct is_simd_mask;
+  template<class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;
 
-template <class T> struct is_simd_flag_type;
-template <class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value;
-
-template <class T, size_t N> struct abi_for_size { using type = see below; };
-template <class T, size_t N> using abi_for_size_t = typename abi_for_size<T, N>::type;
+  template<class T> struct is_simd_flag_type;
+  template<class T> inline constexpr bool is_simd_flag_type_v =
+    is_simd_flag_type<T>::value;
 
-template <class T, class Abi = simd_abi::compatible<T>> struct simd_size;
-template <class T, class Abi = simd_abi::compatible<T>>
-inline constexpr size_t simd_size_v = simd_size<T, Abi>::value;
+  template<class T, class Abi = simd_abi::compatible<T>> struct simd_size;
+  template<class T, class Abi = simd_abi::compatible<T>>
+    inline constexpr size_t simd_size_v = simd_size<T,Abi>::value;
 
-template <class T, class U = typename T::value_type> struct memory_alignment;
-template <class T, class U = typename T::value_type>
-inline constexpr size_t memory_alignment_v = memory_alignment<T, U>::value;
+  template<class T, class U = typename T::value_type> struct memory_alignment;
+  template<class T, class U = typename T::value_type>
+    inline constexpr size_t memory_alignment_v = memory_alignment<T,U>::value;
 
-// class template simd [simd.class]
-template <class T, class Abi = simd_abi::compatible<T>> class simd;
-template <class T> using native_simd = simd<T, simd_abi::native<T>>;
-template <class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;
+  template<class T, class V> struct rebind_simd { using type = see below; };
+  template<class T, class V> using rebind_simd_t = typename rebind_simd<T, V>::type;
+  template<int N, class V> struct resize_simd { using type = see below; };
+  template<int N, class V> using resize_simd_t = typename resize_simd<N, V>::type;
+
+  // 9.6, Class template simd
+  template<class T, class Abi = simd_abi::compatible<T>> class simd;
+  template<class T> using native_simd = simd<T, simd_abi::native<T>>;
+  template<class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;
 
-// class template simd_mask [simd.mask.class]
-template <class T, class Abi = simd_abi::compatible<T>> class simd_mask;
-template <class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;
-template <class T, int N> using fixed_size_simd_mask = simd_mask<T, simd_abi::fixed_size<N>>;
+  // 9.8, Class template simd_mask
+  template<class T, class Abi = simd_abi::compatible<T>> class simd_mask;
+  template<class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;
+  template<class T, int N> using fixed_size_simd_mask =
+    simd_mask<T, simd_abi::fixed_size<N>>;
 
-// casts [simd.casts]
-template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&);
-template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&);
+  // 9.7.5, Casts
+  template<class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&) noexcept;
+  template<class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&) noexcept;
 
-template <class T, class Abi>
-fixed_size_simd<T, simd_size_v<T, Abi>> to_fixed_size(const simd<T, Abi>&) noexcept;
-template <class T, class Abi>
-fixed_size_simd_mask<T, simd_size_v<T, Abi>> to_fixed_size(const simd_mask<T, Abi>&) noexcept;
-template <class T, size_t N> native_simd<T> to_native(const fixed_size_simd<T, N>&) noexcept;
-template <class T, size_t N>
-native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>> &) noexcept;
-template <class T, size_t N> simd<T> to_compatible(const fixed_size_simd<T, N>&) noexcept;
-template <class T, size_t N> simd_mask<T> to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;
+  template<class T, class Abi>
+    fixed_size_simd<T, simd_size_v<T, Abi>>
+      to_fixed_size(const simd<T, Abi>&) noexcept;
+  template<class T, class Abi>
+    fixed_size_simd_mask<T, simd_size_v<T, Abi>>
+      to_fixed_size(const simd_mask<T, Abi>&) noexcept;
+  template<class T, int N>
+    native_simd<T> to_native(const fixed_size_simd<T, N>&) noexcept;
+  template<class T, int N>
+    native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>&) noexcept;
+  template<class T, int N>
+    simd<T> to_compatible(const fixed_size_simd<T, N>&) noexcept;
+  template<class T, int N>
+    simd_mask<T> to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;
 
-template <size_t... Sizes, class T, class Abi>
-tuple<simd<T, abi_for_size_t<Sizes>>...> split(const simd<T, Abi>&);
-template <size_t... Sizes, class T, class Abi>
-tuple<simd_mask<T, abi_for_size_t<Sizes>>...> split(const simd_mask<T, Abi>&);
-template <class V, class Abi>
-array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
-const simd<typename V::value_type, Abi>&);
-template <class V, class Abi>
-array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
-const simd_mask<typename V::value_type, Abi>&);
+  template<size_t... Sizes, class T, class Abi>
+    tuple<simd<T, simd_abi::deduce_t<T, Sizes>>...>
+      split(const simd<T, Abi>&) noexcept;
+  template<size_t... Sizes, class T, class Abi>
+    tuple<simd_mask<T, simd_abi::deduce_t<T, Sizes>>...>
+      split(const simd_mask<T, Abi>&) noexcept;
+  template<class V, class Abi>
+    array<V, simd_size_v<typename V::value_type, Abi> / V::size()>
+      split(const simd<typename V::value_type, Abi>&) noexcept;
+  template<class V, class Abi>
+    array<V, simd_size_v<typename V::simd_type::value_type, Abi> / V::size()>
+      split(const simd_mask<typename V::simd_type::value_type, Abi>&) noexcept;
+
+  template<size_t N, class T, class A>
+    array<resize_simd<simd_size_v<T, A> / N, simd<T, A>>, N>
+      split_by(const simd<T, A>& x) noexcept;
+  template<size_t N, class T, class A>
+    array<resize_simd<simd_size_v<T, A> / N, simd_mask<T, A>>, N>
+      split_by(const simd_mask<T, A>& x) noexcept;
 
-template <class T, class... Abis>
-simd<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd<T, Abis>&...);
-template <class T, class... Abis>
-simd_mask<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd_mask<T, Abis>&...);
+  template<class T, class... Abis>
+    simd<T, simd_abi::deduce_t<T, (simd_size_v<T, Abis> + ...)>>
+      concat(const simd<T, Abis>&...) noexcept;
+  template<class T, class... Abis>
+    simd_mask<T, simd_abi::deduce_t<T, (simd_size_v<T, Abis> + ...)>>
+      concat(const simd_mask<T, Abis>&...) noexcept;
+
+  template<class T, class Abi, size_t N>
+    resize_simd<simd_size_v<T, Abi> * N, simd<T, Abi>>
+      concat(const array<simd<T, Abi>, N>& arr) noexcept;
+  template<class T, class Abi, size_t N>
+    resize_simd<simd_size_v<T, Abi> * N, simd_mask<T, Abi>>
+      concat(const array<simd_mask<T, Abi>, N>& arr) noexcept;
 
-// reductions [simd.mask.reductions]
-template <class T, class Abi> bool all_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> bool any_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> bool none_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> bool some_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> int popcount(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> int find_first_set(const simd_mask<T, Abi>&);
-template <class T, class Abi> int find_last_set(const simd_mask<T, Abi>&);
+  // 9.9.4, Reductions
+  template<class T, class Abi> bool all_of(const simd_mask<T, Abi>&) noexcept;
+  template<class T, class Abi> bool any_of(const simd_mask<T, Abi>&) noexcept;
+  template<class T, class Abi> bool none_of(const simd_mask<T, Abi>&) noexcept;
+  template<class T, class Abi> bool some_of(const simd_mask<T, Abi>&) noexcept;
+  template<class T, class Abi> int popcount(const simd_mask<T, Abi>&) noexcept;
+  template<class T, class Abi> int find_first_set(const simd_mask<T, Abi>&);
+  template<class T, class Abi> int find_last_set(const simd_mask<T, Abi>&);
 
-bool all_of(see below) noexcept;
-bool any_of(see below) noexcept;
-bool none_of(see below) noexcept;
-bool some_of(see below) noexcept;
-int popcount(see below) noexcept;
-int find_first_set(see below) noexcept;
-int find_last_set(see below) noexcept;
+  bool all_of(T) noexcept;
+  bool any_of(T) noexcept;
+  bool none_of(T) noexcept;
+  bool some_of(T) noexcept;
+  int popcount(T) noexcept;
+  int find_first_set(T);
+  int find_last_set(T);
 
-// masked assignment [simd.whereexpr]
-template <class M, class T> class const_where_expression;
-template <class M, class T> class where_expression;
+  // 9.5, Where expression class templates
+  template<class M, class T> class const_where_expression;
+  template<class M, class T> class where_expression;
 
-// masked assignment [simd.mask.where]
-template <class T> struct nodeduce { using type = T; }; // exposition only
-
-template <class T> using nodeduce_t = typename nodeduce<T>::type; // exposition only
-
-template <class T, class Abi>
+  // 9.9.5, Where functions
+  template<class T, class Abi>
     where_expression<simd_mask<T, Abi>, simd<T, Abi>>
       where(const typename simd<T, Abi>::mask_type&, simd<T, Abi>&) noexcept;
 
-template <class T, class Abi>
-const_where_expression<simd_mask<T, Abi>, const simd<T, Abi>>
+  template<class T, class Abi>
+    const_where_expression<simd_mask<T, Abi>, simd<T, Abi>>
       where(const typename simd<T, Abi>::mask_type&, const simd<T, Abi>&) noexcept;
 
-template <class T, class Abi>
+  template<class T, class Abi>
     where_expression<simd_mask<T, Abi>, simd_mask<T, Abi>>
-where(const nodeduce_t<simd_mask<T, Abi>>&, simd_mask<T, Abi>&) noexcept;
+      where(const type_identity_t<simd_mask<T, Abi>>&, simd_mask<T, Abi>&) noexcept;
 
-template <class T, class Abi>
-const_where_expression<simd_mask<T, Abi>, const simd_mask<T, Abi>>
-where(const nodeduce_t<simd_mask<T, Abi>>&, const simd_mask<T, Abi>&) noexcept;
+  template<class T, class Abi>
+    const_where_expression<simd_mask<T, Abi>, simd_mask<T, Abi>>
+      where(const type_identity_t<simd_mask<T, Abi>>&, const simd_mask<T, Abi>&) noexcept;
 
-template <class T> where_expression<bool, T> where(see below k, T& d) noexcept;
+  template<class T>
+    where_expression<bool, T>
+      where(see below k, T& d) noexcept;
 
-template <class T>
-const_where_expression<bool, const T> where(see below k, const T& d) noexcept;
+  template<class T>
+    const_where_expression<bool, T>
+      where(see below k, const T& d) noexcept;
 
-// reductions [simd.reductions]
-template <class T, class Abi, class BinaryOperation = std::plus<>>
-T reduce(const simd<T, Abi>&, BinaryOperation = BinaryOperation());
+  // 9.7.4, Reductions
+  template<class T, class Abi, class BinaryOperation = plus<>>
+    T reduce(const simd<T, Abi>&,
+             BinaryOperation = {});
 
-template <class M, class V, class BinaryOperation>
+  template<class M, class V, class BinaryOperation>
     typename V::value_type reduce(const const_where_expression<M, V>& x,
-typename V::value_type neutral_element, BinaryOperation binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, plus<> binary_op = plus<>());
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, multiplies<> binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, bit_and<> binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, bit_or<> binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, bit_xor<> binary_op);
-
-template <class T, class Abi> T hmin(const simd<T, Abi>&);
-template <class M, class V> T hmin(const const_where_expression<M, V>&);
-template <class T, class Abi> T hmax(const simd<T, Abi>&);
-template <class M, class V> T hmax(const const_where_expression<M, V>&);
-
-// algorithms [simd.alg]
-template <class T, class Abi> simd<T, Abi> min(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
-
-template <class T, class Abi> simd<T, Abi> max(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
+                                  typename V::value_type identity_element,
+                                  BinaryOperation binary_op);
+  template<class M, class V>
+    typename V::value_type reduce(const const_where_expression<M, V>& x,
+                                  plus<> binary_op = {}) noexcept;
+  template<class M, class V>
+    typename V::value_type reduce(const const_where_expression<M, V>& x,
+                                  multiplies<> binary_op) noexcept;
+  template<class M, class V>
+    typename V::value_type reduce(const const_where_expression<M, V>& x,
+                                  bit_and<> binary_op) noexcept;
+  template<class M, class V>
+    typename V::value_type reduce(const const_where_expression<M, V>& x,
+                                  bit_or<> binary_op) noexcept;
+  template<class M, class V>
+    typename V::value_type reduce(const const_where_expression<M, V>& x,
+                                  bit_xor<> binary_op) noexcept;
 
-template <class T, class Abi>
-std::pair<simd<T, Abi>, simd<T, Abi>> minmax(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
-
-template <class T, class Abi>
-simd<T, Abi> clamp(const simd<T, Abi>& v, const simd<T, Abi>& lo, const simd<T, Abi>& hi);
-
-// [simd.whereexpr]
-template <class M, class T>
-class const_where_expression {
-  const M& mask; // exposition only
-  T& data; // exposition only
-public:
-  const_where_expression(const const_where_expression&) = delete;
-  const_where_expression& operator=(const const_where_expression&) = delete;
-  remove_const_t<T> operator-() const &&;
-  template <class U, class Flags> void copy_to(U* mem, Flags f) const &&;
-};
-
-template <class M, class T>
-class where_expression : public const_where_expression<M, T> {
-public:
-  where_expression(const where_expression&) = delete;
-  where_expression& operator=(const where_expression&) = delete;
-  template <class U> void operator=(U&& x);
-  template <class U> void operator+=(U&& x);
-  template <class U> void operator-=(U&& x);
-  template <class U> void operator*=(U&& x);
-  template <class U> void operator/=(U&& x);
-  template <class U> void operator%=(U&& x);
-  template <class U> void operator&=(U&& x);
-  template <class U> void operator|=(U&& x);
-  template <class U> void operator^=(U&& x);
-  template <class U> void operator<<=(U&& x);
-  template <class U> void operator>>=(U&& x);
-  void operator++();
-  void operator++(int);
-  void operator--();
-  void operator--(int);
-  template <class U, class Flags> void copy_from(const U* mem, Flags);
-};
-
-// [simd.class]
-template <class T, class Abi> class simd {
-public:
-  using value_type = T;
-  using reference = see below;
-  using mask_type = simd_mask<T, Abi>;
-
-  using abi_type = Abi;
-  static constexpr size_t size() noexcept;
-  simd() = default;
-
-  // implicit type conversion constructor
-  template <class U> simd(const simd<U, simd_abi::fixed_size<size()>>&);
-
-  // implicit broadcast constructor (see below for constraints)
-  template <class U> simd(U&& value);
-
-  // generator constructor (see below for constraints)
-  template <class G> explicit simd(G&& gen);
-
-  // load constructor
-  template <class U, class Flags> simd(const U* mem, Flags f);
-
-  // loads [simd.load]
-  template <class U, class Flags> void copy_from(const U* mem, Flags f);
-
-  // stores [simd.store]
-  template <class U, class Flags> void copy_to(U* mem, Flags f) const;
-
-  // scalar access [simd.subscr]
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
-
-  // unary operators [simd.unary]
-  simd& operator++();
-  simd operator++(int);
-  simd& operator--();
-  simd operator--(int);
-  mask_type operator!() const;
-  simd operator~() const; // see below
-  simd operator+() const;
-  simd operator-() const;
-
-  // binary operators [simd.binary]
-  friend simd operator+ (const simd&, const simd&);
-  friend simd operator- (const simd&, const simd&);
-  friend simd operator* (const simd&, const simd&);
-  friend simd operator/ (const simd&, const simd&);
-  friend simd operator% (const simd&, const simd&);
-  friend simd operator& (const simd&, const simd&);
-  friend simd operator| (const simd&, const simd&);
-  friend simd operator^ (const simd&, const simd&);
-  friend simd operator<<(const simd&, const simd&);
-  friend simd operator>>(const simd&, const simd&);
-  friend simd operator<<(const simd&, int);
-  friend simd operator>>(const simd&, int);
-
-  // compound assignment [simd.cassign]
-  friend simd& operator+= (simd&, const simd&);
-  friend simd& operator-= (simd&, const simd&);
-  friend simd& operator*= (simd&, const simd&);
-  friend simd& operator/= (simd&, const simd&);
-  friend simd& operator%= (simd&, const simd&);
-
-  friend simd& operator&= (simd&, const simd&);
-  friend simd& operator|= (simd&, const simd&);
-  friend simd& operator^= (simd&, const simd&);
-  friend simd& operator<<=(simd&, const simd&);
-  friend simd& operator>>=(simd&, const simd&);
-  friend simd& operator<<=(simd&, int);
-  friend simd& operator>>=(simd&, int);
-
-  // compares [simd.comparison]
-  friend mask_type operator==(const simd&, const simd&);
-  friend mask_type operator!=(const simd&, const simd&);
-  friend mask_type operator>=(const simd&, const simd&);
-  friend mask_type operator<=(const simd&, const simd&);
-  friend mask_type operator> (const simd&, const simd&);
-  friend mask_type operator< (const simd&, const simd&);
-};
-
-// [simd.math]
-template <class Abi> using scharv = simd<signed char, Abi>; // exposition only
-template <class Abi> using shortv = simd<short, Abi>; // exposition only
-template <class Abi> using intv = simd<int, Abi>; // exposition only
-template <class Abi> using longv = simd<long int, Abi>; // exposition only
-template <class Abi> using llongv = simd<long long int, Abi>; // exposition only
-template <class Abi> using floatv = simd<float, Abi>; // exposition only
-template <class Abi> using doublev = simd<double, Abi>; // exposition only
-template <class Abi> using ldoublev = simd<long double, Abi>; // exposition only
-template <class T, class V> using samesize = fixed_size_simd<T, V::size()>; // exposition only
-
-template <class Abi> floatv<Abi> acos(floatv<Abi> x);
-template <class Abi> doublev<Abi> acos(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> acos(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> asin(floatv<Abi> x);
-template <class Abi> doublev<Abi> asin(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> asin(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> atan(floatv<Abi> x);
-template <class Abi> doublev<Abi> atan(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> atan(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> atan2(floatv<Abi> y, floatv<Abi> x);
-template <class Abi> doublev<Abi> atan2(doublev<Abi> y, doublev<Abi> x);
-template <class Abi> ldoublev<Abi> atan2(ldoublev<Abi> y, ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> cos(floatv<Abi> x);
-template <class Abi> doublev<Abi> cos(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> cos(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> sin(floatv<Abi> x);
-template <class Abi> doublev<Abi> sin(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> sin(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> tan(floatv<Abi> x);
-template <class Abi> doublev<Abi> tan(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> tan(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> acosh(floatv<Abi> x);
-template <class Abi> doublev<Abi> acosh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> acosh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> asinh(floatv<Abi> x);
-template <class Abi> doublev<Abi> asinh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> asinh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> atanh(floatv<Abi> x);
-template <class Abi> doublev<Abi> atanh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> atanh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> cosh(floatv<Abi> x);
-template <class Abi> doublev<Abi> cosh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> cosh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> sinh(floatv<Abi> x);
-template <class Abi> doublev<Abi> sinh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> sinh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> tanh(floatv<Abi> x);
-template <class Abi> doublev<Abi> tanh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> tanh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> exp(floatv<Abi> x);
-template <class Abi> doublev<Abi> exp(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> exp(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> exp2(floatv<Abi> x);
-template <class Abi> doublev<Abi> exp2(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> exp2(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> expm1(floatv<Abi> x);
-template <class Abi> doublev<Abi> expm1(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> expm1(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> frexp(floatv<Abi> value, samesize<int, floatv<Abi>>* exp);
-template <class Abi> doublev<Abi> frexp(doublev<Abi> value, samesize<int, doublev<Abi>>* exp);
-template <class Abi> ldoublev<Abi> frexp(ldoublev<Abi> value, samesize<int, ldoublev<Abi>>* exp);
-
-template <class Abi> samesize<int, floatv<Abi>> ilogb(floatv<Abi> x);
-template <class Abi> samesize<int, doublev<Abi>> ilogb(doublev<Abi> x);
-template <class Abi> samesize<int, ldoublev<Abi>> ilogb(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> ldexp(floatv<Abi> x, samesize<int, floatv<Abi>> exp);
-template <class Abi> doublev<Abi> ldexp(doublev<Abi> x, samesize<int, doublev<Abi>> exp);
-template <class Abi> ldoublev<Abi> ldexp(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> exp);
-
-template <class Abi> floatv<Abi> log(floatv<Abi> x);
-template <class Abi> doublev<Abi> log(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> log10(floatv<Abi> x);
-template <class Abi> doublev<Abi> log10(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log10(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> log1p(floatv<Abi> x);
-template <class Abi> doublev<Abi> log1p(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log1p(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> log2(floatv<Abi> x);
-template <class Abi> doublev<Abi> log2(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log2(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> logb(floatv<Abi> x);
-template <class Abi> doublev<Abi> logb(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> logb(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> modf(floatv<Abi> value, floatv<Abi>* iptr);
-template <class Abi> doublev<Abi> modf(doublev<Abi> value, doublev<Abi>* iptr);
-template <class Abi> ldoublev<Abi> modf(ldoublev<Abi> value, ldoublev<Abi>* iptr);
-
-template <class Abi> floatv<Abi> scalbn(floatv<Abi> x, samesize<int, floatv<Abi>> n);
-template <class Abi> doublev<Abi> scalbn(doublev<Abi> x, samesize<int, doublev<Abi>> n);
-template <class Abi> ldoublev<Abi> scalbn(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> n);
-template <class Abi> floatv<Abi> scalbln(floatv<Abi> x, samesize<long int, floatv<Abi>> n);
-template <class Abi> doublev<Abi> scalbln(doublev<Abi> x, samesize<long int, doublev<Abi>> n);
-template <class Abi> ldoublev<Abi> scalbln(ldoublev<Abi> x, samesize<long int, ldoublev<Abi>> n);
-
-template <class Abi> floatv<Abi> cbrt(floatv<Abi> x);
-template <class Abi> doublev<Abi> cbrt(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> cbrt(ldoublev<Abi> x);
-
-template <class Abi> scharv<Abi> abs(scharv<Abi> j);
-template <class Abi> shortv<Abi> abs(shortv<Abi> j);
-template <class Abi> intv<Abi> abs(intv<Abi> j);
-template <class Abi> longv<Abi> abs(longv<Abi> j);
-template <class Abi> llongv<Abi> abs(llongv<Abi> j);
-template <class Abi> floatv<Abi> abs(floatv<Abi> j);
-template <class Abi> doublev<Abi> abs(doublev<Abi> j);
-template <class Abi> ldoublev<Abi> abs(ldoublev<Abi> j);
-
-template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
-template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
-template <class Abi> ldoublev<Abi> hypot(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
-
-template <class Abi> floatv<Abi> pow(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> pow(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> pow(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> sqrt(floatv<Abi> x);
-template <class Abi> doublev<Abi> sqrt(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> sqrt(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> erf(floatv<Abi> x);
-template <class Abi> doublev<Abi> erf(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> erf(ldoublev<Abi> x);
-template <class Abi> floatv<Abi> erfc(floatv<Abi> x);
-template <class Abi> doublev<Abi> erfc(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> erfc(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> lgamma(floatv<Abi> x);
-template <class Abi> doublev<Abi> lgamma(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> lgamma(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> tgamma(floatv<Abi> x);
-template <class Abi> doublev<Abi> tgamma(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> tgamma(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> ceil(floatv<Abi> x);
-template <class Abi> doublev<Abi> ceil(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> ceil(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> floor(floatv<Abi> x);
-template <class Abi> doublev<Abi> floor(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> floor(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> nearbyint(floatv<Abi> x);
-template <class Abi> doublev<Abi> nearbyint(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> nearbyint(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> rint(floatv<Abi> x);
-template <class Abi> doublev<Abi> rint(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> rint(ldoublev<Abi> x);
-
-template <class Abi> samesize<long int, floatv<Abi>> lrint(floatv<Abi> x);
-template <class Abi> samesize<long int, doublev<Abi>> lrint(doublev<Abi> x);
-template <class Abi> samesize<long int, ldoublev<Abi>> lrint(ldoublev<Abi> x);
-template <class Abi> samesize<long long int, floatv<Abi>> llrint(floatv<Abi> x);
-template <class Abi> samesize<long long int, doublev<Abi>> llrint(doublev<Abi> x);
-template <class Abi> samesize<long long int, ldoublev<Abi>> llrint(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> round(floatv<Abi> x);
-template <class Abi> doublev<Abi> round(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> round(ldoublev<Abi> x);
-template <class Abi> samesize<long int, floatv<Abi>> lround(floatv<Abi> x);
-template <class Abi> samesize<long int, doublev<Abi>> lround(doublev<Abi> x);
-template <class Abi> samesize<long int, ldoublev<Abi>> lround(ldoublev<Abi> x);
-template <class Abi> samesize<long long int, floatv<Abi>> llround(floatv<Abi> x);
-template <class Abi> samesize<long long int, doublev<Abi>> llround(doublev<Abi> x);
-template <class Abi> samesize<long long int, ldoublev<Abi>> llround(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> trunc(floatv<Abi> x);
-template <class Abi> doublev<Abi> trunc(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> trunc(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> fmod(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fmod(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fmod(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> remainder(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> remainder(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> remainder(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> remquo(floatv<Abi> x, floatv<Abi> y, samesize<int, floatv<Abi>>* quo);
-template <class Abi> doublev<Abi> remquo(doublev<Abi> x, doublev<Abi> y, samesize<int, doublev<Abi>>* quo);
-template <class Abi> ldoublev<Abi> remquo(ldoublev<Abi> x, ldoublev<Abi> y, samesize<int, ldoublev<Abi>>* quo);
-
-template <class Abi> floatv<Abi> copysign(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> copysign(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> copysign(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> doublev<Abi> nan(const char* tagp);
-template <class Abi> floatv<Abi> nanf(const char* tagp);
-template <class Abi> ldoublev<Abi> nanl(const char* tagp);
-
-template <class Abi> floatv<Abi> nextafter(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> nextafter(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> nextafter(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> nexttoward(floatv<Abi> x, ldoublev<Abi> y);
-template <class Abi> doublev<Abi> nexttoward(doublev<Abi> x, ldoublev<Abi> y);
-template <class Abi> ldoublev<Abi> nexttoward(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fdim(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fdim(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fdim(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fmax(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fmax(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fmax(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fmin(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fmin(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fmin(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fma(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
-template <class Abi> doublev<Abi> fma(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
-template <class Abi> ldoublev<Abi> fma(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
-
-template <class Abi> samesize<int, floatv<Abi>> fpclassify(floatv<Abi> x);
-template <class Abi> samesize<int, doublev<Abi>> fpclassify(doublev<Abi> x);
-template <class Abi> samesize<int, ldoublev<Abi>> fpclassify(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isfinite(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isfinite(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isfinite(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isinf(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isinf(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isinf(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isnan(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isnan(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isnan(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isnormal(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isnormal(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isnormal(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> signbit(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> signbit(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> signbit(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isgreater(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isgreater(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isgreater(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> isgreaterequal(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isgreaterequal(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isgreaterequal(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> isless(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isless(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isless(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> islessequal(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> islessequal(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> islessequal(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> islessgreater(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> islessgreater(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> islessgreater(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> isunordered(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isunordered(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isunordered(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class V> struct simd_div_t { V quot, rem; };
-template <class Abi> simd_div_t<scharv<Abi>> div(scharv<Abi> numer, scharv<Abi> denom);
-template <class Abi> simd_div_t<shortv<Abi>> div(shortv<Abi> numer, shortv<Abi> denom);
-template <class Abi> simd_div_t<intv<Abi>> div(intv<Abi> numer, intv<Abi> denom);
-template <class Abi> simd_div_t<longv<Abi>> div(longv<Abi> numer, longv<Abi> denom);
-template <class Abi> simd_div_t<llongv<Abi>> div(llongv<Abi> numer, llongv<Abi> denom);
+  template<class T, class Abi>
+    T hmin(const simd<T, Abi>&) noexcept;
+  template<class M, class V>
+    typename V::value_type hmin(const const_where_expression<M, V>&) noexcept;
+  template<class T, class Abi>
+    T hmax(const simd<T, Abi>&) noexcept;
+  template<class M, class V>
+    typename V::value_type hmax(const const_where_expression<M, V>&) noexcept;
 
-// [simd.mask.class]
-template <class T, class Abi>
-class simd_mask {
-public:
-  using value_type = bool;
-  using reference = see below;
-  using simd_type = simd<T, Abi>;
-  using abi_type = Abi;
-  static constexpr size_t size() noexcept;
-  simd_mask() = default;
-
-  // broadcast constructor
-  explicit simd_mask(value_type) noexcept;
-
-  // implicit type conversion constructor
-  template <class U> simd_mask(const simd_mask<U, simd_abi::fixed_size<size()>>&) noexcept;
-
-  // load constructor
-  template <class Flags> simd_mask(const value_type* mem, Flags);
-
-  // loads [simd.mask.copy]
-  template <class Flags> void copy_from(const value_type* mem, Flags);
-  template <class Flags> void copy_to(value_type* mem, Flags) const;
-
-  // scalar access [simd.mask.subscr]
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
-
-  // unary operators [simd.mask.unary]
-  simd_mask operator!() const noexcept;
-
-  // simd_mask binary operators [simd.mask.binary]
-  friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator& (const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator| (const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator^ (const simd_mask&, const simd_mask&) noexcept;
-
-  // simd_mask compound assignment [simd.mask.cassign]
-  friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
-
-  // simd_mask compares [simd.mask.comparison]
-  friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
-};
-
+  // 9.7.6, Algorithms
+  template<class T, class Abi>
+    simd<T, Abi>
+      min(const simd<T, Abi>& a, const simd<T, Abi>& b) noexcept;
+  template<class T, class Abi>
+    simd<T, Abi>
+      max(const simd<T, Abi>& a, const simd<T, Abi>& b) noexcept;
+  template<class T, class Abi>
+    pair<simd<T, Abi>, simd<T, Abi>>
+      minmax(const simd<T, Abi>& a, const simd<T, Abi>& b) noexcept;
+  template<class T, class Abi>
+    simd<T, Abi>
+      clamp(const simd<T, Abi>& v,
+            const simd<T, Abi>& lo,
+            const simd<T, Abi>& hi);
 } // parallelism_v2
 } // std::experimental
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/operations.h>
 #include <array>
-#include <cstddef>
 #include <experimental/__config>
+#include <experimental/__simd/scalar.h>
+#include <experimental/__simd/utility.h>
+#include <experimental/__simd/vec_ext.h>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
-
 #if _LIBCPP_STD_VER >= 17
 
-enum class _StorageKind {
-  _Scalar,
-  _Array,
-  _VecExt,
-};
-
-template <_StorageKind __kind, int _Np>
-struct __simd_abi {};
-
-template <class _Tp, class _Abi>
-class __simd_storage {};
-
-template <class _Tp, int __num_element>
-class __simd_storage<_Tp, __simd_abi<_StorageKind::_Array, __num_element>> {
-  std::array<_Tp, __num_element> __storage_;
-
-  template <class, class>
-  friend struct simd;
-
-  template <class, class>
-  friend struct simd_mask;
-
-public:
-  _Tp __get(size_t __index) const noexcept { return __storage_[__index]; }
-  void __set(size_t __index, _Tp __val) noexcept {
-    __storage_[__index] = __val;
-  }
-};
-
-template <class _Tp>
-class __simd_storage<_Tp, __simd_abi<_StorageKind::_Scalar, 1>> {
-  _Tp __storage_;
-
-  template <class, class>
-  friend struct simd;
-
-  template <class, class>
-  friend struct simd_mask;
-
-public:
-  _Tp __get(size_t __index) const noexcept { return (&__storage_)[__index]; }
-  void __set(size_t __index, _Tp __val) noexcept {
-    (&__storage_)[__index] = __val;
-  }
-};
-
-#ifndef _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-_LIBCPP_HIDE_FROM_ABI constexpr size_t __floor_pow_of_2(size_t __val) {
-  return ((__val - 1) & __val) == 0 ? __val
-                                    : __floor_pow_of_2((__val - 1) & __val);
-}
-
-_LIBCPP_HIDE_FROM_ABI constexpr size_t __ceil_pow_of_2(size_t __val) {
-  return __val == 1 ? 1 : __floor_pow_of_2(__val - 1) << 1;
-}
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
 
-template <class _Tp, size_t __bytes>
-struct __vec_ext_traits {
-#if !defined(_LIBCPP_COMPILER_CLANG_BASED)
-  typedef _Tp type __attribute__((vector_size(__ceil_pow_of_2(__bytes))));
-#endif
+using scalar = __scalar;
+template<int _Np> using fixed_size = __vec_ext<_Np>;
+template<class _Tp> inline constexpr int max_fixed_size = 32;
+template<class _Tp> using compatible = __vec_ext<16 / sizeof(_Tp)>;
+template<class _Tp> using native = __vec_ext<_LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
+
+// TODO: Refine implementation-defined deduce ABI
+template<class _Tp, size_t _Np, class... Abis> struct deduce {
+  using type = fixed_size<_Np>;
 };
+template<class _Tp, size_t _Np, class... _Abis> using deduce_t =
+  typename deduce<_Tp, _Np, _Abis...>::type;
 
-#if defined(_LIBCPP_COMPILER_CLANG_BASED)
-#define _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, _NUM_ELEMENT)                        \
-  template <>                                                                  \
-  struct __vec_ext_traits<_TYPE, sizeof(_TYPE) * _NUM_ELEMENT> {               \
-    using type =                                                               \
-        _TYPE __attribute__((vector_size(sizeof(_TYPE) * _NUM_ELEMENT)));      \
-  }
-
-#define _LIBCPP_SPECIALIZE_VEC_EXT_32(_TYPE)                                   \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 1);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 2);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 3);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 4);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 5);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 6);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 7);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 8);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 9);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 10);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 11);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 12);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 13);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 14);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 15);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 16);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 17);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 18);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 19);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 20);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 21);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 22);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 23);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 24);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 25);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 26);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 27);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 28);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 29);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 30);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 31);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 32)
-
-_LIBCPP_SPECIALIZE_VEC_EXT_32(char);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(char16_t);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(char32_t);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(wchar_t);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed char);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed short);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed int);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed long long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned char);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned short);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned int);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned long long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(float);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(double);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(long double);
-
-#undef _LIBCPP_SPECIALIZE_VEC_EXT_32
-#undef _LIBCPP_SPECIALIZE_VEC_EXT
-#endif
-
-template <class _Tp, int __num_element>
-class __simd_storage<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>> {
-  using _StorageType =
-      typename __vec_ext_traits<_Tp, sizeof(_Tp) * __num_element>::type;
-
-  _StorageType __storage_;
-
-  template <class, class>
-  friend struct simd;
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
 
-  template <class, class>
-  friend struct simd_mask;
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
 
+template<class _Vp> class __simd_reference { // exposition only
 public:
-  _Tp __get(size_t __index) const noexcept { return __storage_[__index]; }
-  void __set(size_t __index, _Tp __val) noexcept {
-    __storage_[__index] = __val;
-  }
-};
-
-#endif // _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-template <class _Vp, class _Tp, class _Abi>
-class __simd_reference {
-  static_assert(std::is_same<_Vp, _Tp>::value, "");
-
-  template <class, class>
-  friend struct simd;
-
-  template <class, class>
-  friend struct simd_mask;
+  using value_type = _Vp;
 
-  __simd_storage<_Tp, _Abi>* __ptr_;
-  size_t __index_;
-
-  __simd_reference(__simd_storage<_Tp, _Abi>* __ptr, size_t __index)
-      : __ptr_(__ptr), __index_(__index) {}
-
-  __simd_reference(const __simd_reference&) = default;
-
-public:
   __simd_reference() = delete;
-  __simd_reference& operator=(const __simd_reference&) = delete;
-
-  operator _Vp() const { return __ptr_->__get(__index_); }
-
-  __simd_reference operator=(_Vp __value) && {
-    __ptr_->__set(__index_, __value);
-    return *this;
-  }
-
-  __simd_reference operator++() && {
-    return std::move(*this) = __ptr_->__get(__index_) + 1;
-  }
-
-  _Vp operator++(int) && {
-    auto __val = __ptr_->__get(__index_);
-    __ptr_->__set(__index_, __val + 1);
-    return __val;
-  }
-
-  __simd_reference operator--() && {
-    return std::move(*this) = __ptr_->__get(__index_) - 1;
-  }
-
-  _Vp operator--(int) && {
-    auto __val = __ptr_->__get(__index_);
-    __ptr_->__set(__index_, __val - 1);
-    return __val;
-  }
-
-  __simd_reference operator+=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) + __value;
-  }
-
-  __simd_reference operator-=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) - __value;
-  }
-
-  __simd_reference operator*=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) * __value;
-  }
-
-  __simd_reference operator/=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) / __value;
-  }
-
-  __simd_reference operator%=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) % __value;
-  }
-
-  __simd_reference operator>>=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) >> __value;
-  }
-
-  __simd_reference operator<<=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) << __value;
-  }
-
-  __simd_reference operator&=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) & __value;
-  }
-
-  __simd_reference operator|=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) | __value;
-  }
-
-  __simd_reference operator^=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) ^ __value;
-  }
-};
-
-template <class _To, class _From>
-_LIBCPP_HIDE_FROM_ABI constexpr decltype(_To{std::declval<_From>()}, true)
-__is_non_narrowing_convertible_impl(_From) {
-  return true;
-}
-
-template <class _To>
-_LIBCPP_HIDE_FROM_ABI constexpr bool __is_non_narrowing_convertible_impl(...) {
-  return false;
-}
+  __simd_reference(const __simd_reference&) = delete;
 
-template <class _From, class _To>
-_LIBCPP_HIDE_FROM_ABI
-constexpr typename std::enable_if<std::is_arithmetic<_To>::value &&
-                                      std::is_arithmetic<_From>::value,
-                                  bool>::type
-__is_non_narrowing_arithmetic_convertible() {
-  return experimental::__is_non_narrowing_convertible_impl<_To>(_From{});
-}
-
-template <class _From, class _To>
-_LIBCPP_HIDE_FROM_ABI
-constexpr typename std::enable_if<!(std::is_arithmetic<_To>::value &&
-                                    std::is_arithmetic<_From>::value),
-                                  bool>::type
-__is_non_narrowing_arithmetic_convertible() {
-  return false;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp __variadic_sum() {
-  return _Tp{};
-}
+  operator value_type() const noexcept;
 
-template <class _Tp, class _Up, class... _Args>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp __variadic_sum(_Up __first, _Args... __rest) {
-  return static_cast<_Tp>(__first) + experimental::__variadic_sum<_Tp>(__rest...);
-}
+  template<class _Up> __simd_reference operator=(_Up&& __x) && noexcept;
 
-template <class _Tp>
-struct __nodeduce {
-  using type = _Tp;
+  template<class _Up> __simd_reference operator+=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator-=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator*=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator/=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator%=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator|=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator&=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator^=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator<<=(_Up&& __x) && noexcept;
+  template<class _Up> __simd_reference operator>>=(_Up&& __x) && noexcept;
+
+  __simd_reference operator++() && noexcept;
+  value_type operator++(int) && noexcept;
+  __simd_reference operator--() && noexcept;
+  value_type operator--(int) && noexcept;
+
+  friend void swap(__simd_reference&& __a, __simd_reference&& __b) noexcept;
+  friend void swap(value_type& __a, __simd_reference&& __b) noexcept;
+  friend void swap(__simd_reference&& __a, value_type& __b) noexcept;
 };
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool __vectorizable() {
-  return std::is_arithmetic<_Tp>::value && !std::is_const<_Tp>::value &&
-         !std::is_volatile<_Tp>::value && !std::is_same<_Tp, bool>::value;
-}
-
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
-
-using scalar = __simd_abi<_StorageKind::_Scalar, 1>;
-
-template <int _Np>
-using fixed_size = __simd_abi<_StorageKind::_Array, _Np>;
-
-template <class _Tp>
-inline constexpr size_t max_fixed_size = 32;
-
-template <class _Tp>
-using compatible = fixed_size<16 / sizeof(_Tp)>;
-
-#ifndef _LIBCPP_HAS_NO_VECTOR_EXTENSION
-template <class _Tp>
-using native = __simd_abi<_StorageKind::_VecExt,
-                          _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
-#else
-template <class _Tp>
-using native =
-    fixed_size<_Tp, _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
-#endif // _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
-
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
-class simd;
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
-class simd_mask;
-
 struct element_aligned_tag {};
 struct vector_aligned_tag {};
-template <size_t>
-struct overaligned_tag {};
+template<size_t> struct overaligned_tag {};
 inline constexpr element_aligned_tag element_aligned{};
 inline constexpr vector_aligned_tag vector_aligned{};
-template <size_t _Np>
-inline constexpr overaligned_tag<_Np> overaligned{};
-
-// traits [simd.traits]
-template <class _Tp>
-struct is_abi_tag : std::integral_constant<bool, false> {};
-
-template <_StorageKind __kind, int _Np>
-struct is_abi_tag<__simd_abi<__kind, _Np>>
-    : std::integral_constant<bool, true> {};
-
-template <class _Tp>
-struct is_simd : std::integral_constant<bool, false> {};
-
-template <class _Tp, class _Abi>
-struct is_simd<simd<_Tp, _Abi>> : std::integral_constant<bool, true> {};
-
-template <class _Tp>
-struct is_simd_mask : std::integral_constant<bool, false> {};
-
-template <class _Tp, class _Abi>
-struct is_simd_mask<simd_mask<_Tp, _Abi>> : std::integral_constant<bool, true> {
-};
-
-template <class _Tp>
-struct is_simd_flag_type : std::integral_constant<bool, false> {};
-
-template <>
-struct is_simd_flag_type<element_aligned_tag>
-    : std::integral_constant<bool, true> {};
-
-template <>
-struct is_simd_flag_type<vector_aligned_tag>
-    : std::integral_constant<bool, true> {};
-
-template <size_t _Align>
-struct is_simd_flag_type<overaligned_tag<_Align>>
-    : std::integral_constant<bool, true> {};
-
-template <class _Tp>
-inline constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;
-template <class _Tp>
-inline constexpr bool is_simd_v = is_simd<_Tp>::value;
-template <class _Tp>
-inline constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;
-template <class _Tp>
-inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<_Tp>::value;
-template <class _Tp, size_t _Np>
-struct abi_for_size {
-  using type = simd_abi::fixed_size<_Np>;
-};
-template <class _Tp, size_t _Np>
-using abi_for_size_t = typename abi_for_size<_Tp, _Np>::type;
-
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
-struct simd_size;
-
-template <class _Tp, _StorageKind __kind, int _Np>
-struct simd_size<_Tp, __simd_abi<__kind, _Np>>
-    : std::integral_constant<size_t, _Np> {
-  static_assert(
-      std::is_arithmetic<_Tp>::value &&
-          !std::is_same<__remove_const_t<_Tp>, bool>::value,
-      "Element type should be vectorizable");
-};
-
-// TODO: implement it.
-template <class _Tp, class _Up = typename _Tp::value_type>
-struct memory_alignment;
+template<size_t _Np> inline constexpr overaligned_tag<_Np> overaligned{};
 
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+// 9.6, Class template simd
+template<class _Tp, class _Abi = simd_abi::compatible<_Tp>> class simd;
+template<class _Tp> using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
+template<class _Tp, int _Np> using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
+
+// 9.8, Class template simd_mask
+template<class _Tp, class _Abi = simd_abi::compatible<_Tp>> class simd_mask;
+template<class _Tp> using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
+template<class _Tp, int _Np> using fixed_size_simd_mask =
+  simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
+
+// 9.4, simd type traits
+template<class _Tp, class = void> struct __is_abi_tag_impl : false_type {};
+template<class _Tp> struct __is_abi_tag_impl<_Tp, enable_if_t<_Tp::__is_abi_tag>> : bool_constant<_Tp::__is_abi_tag> {};
+template<class _Tp> struct is_abi_tag : __is_abi_tag_impl<_Tp> {};
+template<class _Tp> inline constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;
+
+template<class _Tp> struct is_simd;
+template<class _Tp> inline constexpr bool is_simd_v = is_simd<_Tp>::value;
+
+template<class _Tp> struct is_simd_mask;
+template<class _Tp> inline constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;
+
+template<class _Tp> struct is_simd_flag_type;
+template<class _Tp> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<_Tp>::value;
+
+template<class _Tp, class _Abi, class = void> struct __simd_size_impl {};
+template<class _Tp, class _Abi>
+  struct __simd_size_impl<_Tp, _Abi, enable_if_t<__is_vectorizable<_Tp>() && is_abi_tag_v<_Abi>>>
+    : integral_constant<size_t, _Abi::__simd_size> {};
+template<class _Tp, class _Abi = simd_abi::compatible<_Tp>> struct simd_size : __simd_size_impl<_Tp, _Abi> {};
+template<class _Tp, class _Abi = simd_abi::compatible<_Tp>>
   inline constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
 
-template <class _Tp, class _Up = typename _Tp::value_type>
+template<class _Tp, class _Up = typename _Tp::value_type> struct memory_alignment;
+template<class _Tp, class _Up = typename _Tp::value_type>
   inline constexpr size_t memory_alignment_v = memory_alignment<_Tp, _Up>::value;
 
-// class template simd [simd.class]
-template <class _Tp>
-using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
-template <class _Tp, int _Np>
-using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
-
-// class template simd_mask [simd.mask.class]
-template <class _Tp>
-using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
-
-template <class _Tp, int _Np>
-using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
-
-// casts [simd.casts]
-template <class _Tp>
-struct __static_simd_cast_traits {
-  template <class _Up, class _Abi>
-  static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp, class _NewAbi>
-struct __static_simd_cast_traits<simd<_Tp, _NewAbi>> {
-  template <class _Up, class _Abi>
-  static typename std::enable_if<simd<_Up, _Abi>::size() ==
-                                     simd<_Tp, _NewAbi>::size(),
-                                 simd<_Tp, _NewAbi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp>
-struct __simd_cast_traits {
-  template <class _Up, class _Abi>
-  static typename std::enable_if<
-      __is_non_narrowing_arithmetic_convertible<_Up, _Tp>(),
-      simd<_Tp, _Abi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp, class _NewAbi>
-struct __simd_cast_traits<simd<_Tp, _NewAbi>> {
-  template <class _Up, class _Abi>
-  static typename std::enable_if<
-      __is_non_narrowing_arithmetic_convertible<_Up, _Tp>() &&
-          simd<_Up, _Abi>::size() == simd<_Tp, _NewAbi>::size(),
-      simd<_Tp, _NewAbi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp, class _Up, class _Abi>
-_LIBCPP_HIDE_FROM_ABI auto simd_cast(const simd<_Up, _Abi>& __v)
-    -> decltype(__simd_cast_traits<_Tp>::__apply(__v)) {
-  return __simd_cast_traits<_Tp>::__apply(__v);
-}
+template<class _Tp, class _Vp> struct rebind_simd { using type = void; };
+template<class _Tp, class _Vp> using rebind_simd_t = typename rebind_simd<_Tp, _Vp>::type;
+template<int _Np, class _Vp> struct resize_simd { using type = void; };
+template<int _Np, class _Vp> using resize_simd_t = typename resize_simd<_Np, _Vp>::type;
 
-template <class _Tp, class _Up, class _Abi>
-_LIBCPP_HIDE_FROM_ABI auto static_simd_cast(const simd<_Up, _Abi>& __v)
-    -> decltype(__static_simd_cast_traits<_Tp>::__apply(__v)) {
-  return __static_simd_cast_traits<_Tp>::__apply(__v);
-}
+// 9.7.5, Casts
+template<class _Tp, class _Up, class _Abi> void simd_cast(const simd<_Up, _Abi>&) noexcept;
+template<class _Tp, class _Up, class _Abi> void static_simd_cast(const simd<_Up, _Abi>&) noexcept;
 
-template <class _Tp, class _Abi>
-fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>
+template<class _Tp, class _Abi>
+  fixed_size_simd<_Tp, simd_size_v<_Tp, _Abi>>
     to_fixed_size(const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
+template<class _Tp, class _Abi>
+  fixed_size_simd_mask<_Tp, simd_size_v<_Tp, _Abi>>
     to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, size_t _Np>
+template<class _Tp, int _Np>
   native_simd<_Tp> to_native(const fixed_size_simd<_Tp, _Np>&) noexcept;
-
-template <class _Tp, size_t _Np>
+template<class _Tp, int _Np>
   native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
-
-template <class _Tp, size_t _Np>
+template<class _Tp, int _Np>
   simd<_Tp> to_compatible(const fixed_size_simd<_Tp, _Np>&) noexcept;
-
-template <class _Tp, size_t _Np>
+template<class _Tp, int _Np>
   simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
 
-template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd<_Tp, abi_for_size_t<_Tp, __sizes>>...> split(const simd<_Tp, _Abi>&);
-
-template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd_mask<_Tp, abi_for_size_t<_Tp, __sizes>>...>
-split(const simd_mask<_Tp, _Abi>&);
-
-template <class _SimdType, class _Abi>
-array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
-                     _SimdType::size()>
-split(const simd<typename _SimdType::value_type, _Abi>&);
-
-template <class _SimdType, class _Abi>
-array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
-                     _SimdType::size()>
-split(const simd_mask<typename _SimdType::value_type, _Abi>&);
+template<size_t... _Sizes, class _Tp, class _Abi>
+  tuple<simd<_Tp, simd_abi::deduce_t<_Tp, _Sizes>>...>
+    split(const simd<_Tp, _Abi>&) noexcept;
+template<size_t... _Sizes, class _Tp, class _Abi>
+  tuple<simd_mask<_Tp, simd_abi::deduce_t<_Tp, _Sizes>>...>
+    split(const simd_mask<_Tp, _Abi>&) noexcept;
+template<class _Vp, class _Abi>
+  array<_Vp, simd_size_v<typename _Vp::value_type, _Abi> / _Vp::size()>
+    split(const simd<typename _Vp::value_type, _Abi>&) noexcept;
+template<class _Vp, class _Abi>
+  array<_Vp, simd_size_v<typename _Vp::simd_type::value_type, _Abi> / _Vp::size()>
+    split(const simd_mask<typename _Vp::simd_type::value_type, _Abi>&) noexcept;
+
+template<size_t _Np, class _Tp, class _Abi>
+  array<resize_simd<simd_size_v<_Tp, _Abi> / _Np, simd<_Tp, _Abi>>, _Np>
+    split_by(const simd<_Tp, _Abi>& __x) noexcept;
+template<size_t _Np, class _Tp, class _Abi>
+  array<resize_simd<simd_size_v<_Tp, _Abi> / _Np, simd_mask<_Tp, _Abi>>, _Np>
+    split_by(const simd_mask<_Tp, _Abi>& __x) noexcept;
 
-template <class _Tp, class... _Abis>
-simd<_Tp, abi_for_size_t<_Tp, experimental::__variadic_sum(simd_size<_Tp, _Abis>::value...)>>
-concat(const simd<_Tp, _Abis>&...);
-
-template <class _Tp, class... _Abis>
-simd_mask<_Tp,
-          abi_for_size_t<_Tp, experimental::__variadic_sum(simd_size<_Tp, _Abis>::value...)>>
-concat(const simd_mask<_Tp, _Abis>&...);
+template<class _Tp, class... _Abis>
+  simd<_Tp, simd_abi::deduce_t<_Tp, (simd_size_v<_Tp, _Abis> + ...)>>
+    concat(const simd<_Tp, _Abis>&...) noexcept;
+template<class _Tp, class... _Abis>
+  simd_mask<_Tp, simd_abi::deduce_t<_Tp, (simd_size_v<_Tp, _Abis> + ...)>>
+    concat(const simd_mask<_Tp, _Abis>&...) noexcept;
 
-// reductions [simd.mask.reductions]
-template <class _Tp, class _Abi>
-bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-int popcount(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-int find_first_set(const simd_mask<_Tp, _Abi>&);
-template <class _Tp, class _Abi>
-int find_last_set(const simd_mask<_Tp, _Abi>&);
-bool all_of(bool) noexcept;
-bool any_of(bool) noexcept;
-bool none_of(bool) noexcept;
-bool some_of(bool) noexcept;
-int popcount(bool) noexcept;
-int find_first_set(bool) noexcept;
-int find_last_set(bool) noexcept;
-
-// masked assignment [simd.whereexpr]
-template <class _MaskType, class _Tp>
-class const_where_expression;
-template <class _MaskType, class _Tp>
-class where_expression;
+template<class _Tp, class _Abi, size_t _Np>
+  resize_simd<simd_size_v<_Tp, _Abi> * _Np, simd<_Tp, _Abi>>
+    concat(const array<simd<_Tp, _Abi>, _Np>& __arr) noexcept;
+template<class _Tp, class _Abi, size_t _Np>
+  resize_simd<simd_size_v<_Tp, _Abi> * _Np, simd_mask<_Tp, _Abi>>
+    concat(const array<simd_mask<_Tp, _Abi>, _Np>& __arr) noexcept;
+
+// 9.9.4, Reductions
+template<class _Tp, class _Abi> bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template<class _Tp, class _Abi> bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template<class _Tp, class _Abi> bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template<class _Tp, class _Abi> bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;
+template<class _Tp, class _Abi> int popcount(const simd_mask<_Tp, _Abi>&) noexcept;
+template<class _Tp, class _Abi> int find_first_set(const simd_mask<_Tp, _Abi>&);
+template<class _Tp, class _Abi> int find_last_set(const simd_mask<_Tp, _Abi>&);
+
+bool all_of(_Bool) noexcept;
+bool any_of(_Bool) noexcept;
+bool none_of(_Bool) noexcept;
+bool some_of(_Bool) noexcept;
+int popcount(_Bool) noexcept;
+int find_first_set(_Bool);
+int find_last_set(_Bool);
+
+// 9.5, Where expression class templates
+template<class _Mp, class _Tp> class const_where_expression;
+template<class _Mp, class _Tp> class where_expression;
 
-// masked assignment [simd.mask.where]
-template <class _Tp, class _Abi>
+// 9.9.5, Where functions
+template<class _Tp, class _Abi>
   where_expression<simd_mask<_Tp, _Abi>, simd<_Tp, _Abi>>
     where(const typename simd<_Tp, _Abi>::mask_type&, simd<_Tp, _Abi>&) noexcept;
 
-template <class _Tp, class _Abi>
-const_where_expression<simd_mask<_Tp, _Abi>, const simd<_Tp, _Abi>>
-where(const typename simd<_Tp, _Abi>::mask_type&,
-      const simd<_Tp, _Abi>&) noexcept;
+template<class _Tp, class _Abi>
+  const_where_expression<simd_mask<_Tp, _Abi>, simd<_Tp, _Abi>>
+    where(const typename simd<_Tp, _Abi>::mask_type&, const simd<_Tp, _Abi>&) noexcept;
 
-template <class _Tp, class _Abi>
+template<class _Tp, class _Abi>
   where_expression<simd_mask<_Tp, _Abi>, simd_mask<_Tp, _Abi>>
-where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
-      simd_mask<_Tp, _Abi>&) noexcept;
+    where(const type_identity_t<simd_mask<_Tp, _Abi>>&, simd_mask<_Tp, _Abi>&) noexcept;
 
-template <class _Tp, class _Abi>
-const_where_expression<simd_mask<_Tp, _Abi>, const simd_mask<_Tp, _Abi>>
-where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
-      const simd_mask<_Tp, _Abi>&) noexcept;
+template<class _Tp, class _Abi>
+  const_where_expression<simd_mask<_Tp, _Abi>, simd_mask<_Tp, _Abi>>
+    where(const type_identity_t<simd_mask<_Tp, _Abi>>&, const simd_mask<_Tp, _Abi>&) noexcept;
 
-template <class _Tp>
-where_expression<bool, _Tp> where(bool, _Tp&) noexcept;
+template<class _Tp>
+  where_expression<bool, _Tp>
+    where(_Bool __k, _Tp& __d) noexcept;
 
-template <class _Tp>
-const_where_expression<bool, const _Tp> where(bool, const _Tp&) noexcept;
+template<class _Tp>
+  const_where_expression<bool, _Tp>
+    where(_Bool __k, const _Tp& __d) noexcept;
+
 
-// reductions [simd.reductions]
-template <class _Tp, class _Abi, class _BinaryOp = std::plus<_Tp>>
-_Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp());
-
-template <class _MaskType, class _SimdType, class _BinaryOp>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       typename _SimdType::value_type __neutral_element, _BinaryOp);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       plus<typename _SimdType::value_type> = {});
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       multiplies<typename _SimdType::value_type>);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_and<typename _SimdType::value_type>);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_or<typename _SimdType::value_type>);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_xor<typename _SimdType::value_type>);
+// 9.7.4, Reductions
+template<class _Tp, class _Abi, class _BinaryOperation = plus<>>
+  _Tp reduce(const simd<_Tp, _Abi>&,
+            _BinaryOperation = {});
+
+template<class _Mp, class _Vp, class _BinaryOperation>
+  typename _Vp::value_type reduce(const const_where_expression<_Mp, _Vp>& __x,
+                                typename _Vp::value_type __identity_element,
+                                _BinaryOperation __binary_op);
+template<class _Mp, class _Vp>
+  typename _Vp::value_type reduce(const const_where_expression<_Mp, _Vp>& __x,
+                                plus<> __binary_op = {}) noexcept;
+template<class _Mp, class _Vp>
+  typename _Vp::value_type reduce(const const_where_expression<_Mp, _Vp>& __x,
+                                multiplies<> __binary_op) noexcept;
+template<class _Mp, class _Vp>
+  typename _Vp::value_type reduce(const const_where_expression<_Mp, _Vp>& __x,
+                                bit_and<> __binary_op) noexcept;
+template<class _Mp, class _Vp>
+  typename _Vp::value_type reduce(const const_where_expression<_Mp, _Vp>& __x,
+                                bit_or<> __binary_op) noexcept;
+template<class _Mp, class _Vp>
+  typename _Vp::value_type reduce(const const_where_expression<_Mp, _Vp>& __x,
+                                bit_xor<> __binary_op) noexcept;
 
-template <class _Tp, class _Abi>
-_Tp hmin(const simd<_Tp, _Abi>&);
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-hmin(const const_where_expression<_MaskType, _SimdType>&);
-template <class _Tp, class _Abi>
-_Tp hmax(const simd<_Tp, _Abi>&);
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-hmax(const const_where_expression<_MaskType, _SimdType>&);
+template<class _Tp, class _Abi>
+  _Tp hmin(const simd<_Tp, _Abi>&) noexcept;
+template<class _Mp, class _Vp>
+  typename _Vp::value_type hmin(const const_where_expression<_Mp, _Vp>&) noexcept;
+template<class _Tp, class _Abi>
+  _Tp hmax(const simd<_Tp, _Abi>&) noexcept;
+template<class _Mp, class _Vp>
+  typename _Vp::value_type hmax(const const_where_expression<_Mp, _Vp>&) noexcept;
 
-// algorithms [simd.alg]
-template <class _Tp, class _Abi>
-simd<_Tp, _Abi> min(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-simd<_Tp, _Abi> max(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-std::pair<simd<_Tp, _Abi>, simd<_Tp, _Abi>>
-minmax(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-simd<_Tp, _Abi> clamp(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&,
-                      const simd<_Tp, _Abi>&);
+// 9.7.6, Algorithms
+template<class _Tp, class _Abi>
+  simd<_Tp, _Abi>
+    min(const simd<_Tp, _Abi>& __a, const simd<_Tp, _Abi>& __b) noexcept;
+template<class _Tp, class _Abi>
+  simd<_Tp, _Abi>
+    max(const simd<_Tp, _Abi>& __a, const simd<_Tp, _Abi>& __b) noexcept;
+template<class _Tp, class _Abi>
+  pair<simd<_Tp, _Abi>, simd<_Tp, _Abi>>
+    minmax(const simd<_Tp, _Abi>& __a, const simd<_Tp, _Abi>& __b) noexcept;
+template<class _Tp, class _Abi>
+  simd<_Tp, _Abi>
+    clamp(const simd<_Tp, _Abi>& __v,
+          const simd<_Tp, _Abi>& __lo,
+          const simd<_Tp, _Abi>& __hi);
+
+
+// 9.5, Where expression class templates defination
+template<class _Mp, class _Tp> class const_where_expression {
+  const _Mp __mask;   // exposition only
+  _Tp& __data;        // exposition only
 
-// [simd.whereexpr]
-// TODO implement where expressions.
-template <class _MaskType, class _Tp>
-class const_where_expression {
 public:
   const_where_expression(const const_where_expression&) = delete;
   const_where_expression& operator=(const const_where_expression&) = delete;
-  __remove_const_t<_Tp> operator-() const&&;
-  template <class _Up, class _Flags>
-  void copy_to(_Up*, _Flags) const&&;
-};
 
-template <class _MaskType, class _Tp>
-class where_expression : public const_where_expression<_MaskType, _Tp> {
-public:
-  where_expression(const where_expression&) = delete;
-  where_expression& operator=(const where_expression&) = delete;
-  template <class _Up>
-  void operator=(_Up&&);
-  template <class _Up>
-  void operator+=(_Up&&);
-  template <class _Up>
-  void operator-=(_Up&&);
-  template <class _Up>
-  void operator*=(_Up&&);
-  template <class _Up>
-  void operator/=(_Up&&);
-  template <class _Up>
-  void operator%=(_Up&&);
-  template <class _Up>
-  void operator&=(_Up&&);
-  template <class _Up>
-  void operator|=(_Up&&);
-  template <class _Up>
-  void operator^=(_Up&&);
-  template <class _Up>
-  void operator<<=(_Up&&);
-  template <class _Up>
-  void operator>>=(_Up&&);
-  void operator++();
-  void operator++(int);
-  void operator--();
-  void operator--(int);
-  template <class _Up, class _Flags>
-  void copy_from(const _Up*, _Flags);
+  _Tp operator-() const && noexcept;
+  _Tp operator+() const && noexcept;
+  _Tp operator~() const && noexcept;
+
+  template<class _Up, class _Flags> void copy_to(_Up* __mem, _Flags) const &&;
+};
+
+template<class _Mp, class _Tp>
+class where_expression : public const_where_expression<_Mp, _Tp> {
+public:
+  template<class _Up> void operator=(_Up&& x) && noexcept;
+  template<class _Up> void operator+=(_Up&& x) && noexcept;
+  template<class _Up> void operator-=(_Up&& x) && noexcept;
+  template<class _Up> void operator*=(_Up&& x) && noexcept;
+  template<class _Up> void operator/=(_Up&& x) && noexcept;
+  template<class _Up> void operator%=(_Up&& x) && noexcept;
+  template<class _Up> void operator&=(_Up&& x) && noexcept;
+  template<class _Up> void operator|=(_Up&& x) && noexcept;
+  template<class _Up> void operator^=(_Up&& x) && noexcept;
+  template<class _Up> void operator<<=(_Up&& x) && noexcept;
+  template<class _Up> void operator>>=(_Up&& x) && noexcept;
+
+  void operator++() && noexcept;
+  void operator++(int) && noexcept;
+  void operator--() && noexcept;
+  void operator--(int) && noexcept;
+
+  template<class _Up, class _Flags> void copy_from(const _Up* __mem, _Flags) &&;
 };
 
-// [simd.class]
-// TODO: implement simd
-template <class _Tp, class _Abi>
-class simd {
+// 9.6, Class template simd defination
+template<class _Tp, class _Abi> class simd {
 public:
   using value_type = _Tp;
-  using reference = __simd_reference<_Tp, _Tp, _Abi>;
+  using reference = __simd_reference<value_type>;
   using mask_type = simd_mask<_Tp, _Abi>;
   using abi_type = _Abi;
 
-  simd() = default;
-  simd(const simd&) = default;
-  simd& operator=(const simd&) = default;
-
-  static constexpr size_t size() noexcept {
-    return simd_size<_Tp, _Abi>::value;
-  }
-
-private:
-  __simd_storage<_Tp, _Abi> __s_;
-
-  template <class _Up>
-  static constexpr bool __can_broadcast() {
-    return (std::is_arithmetic<_Up>::value &&
-            __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) ||
-           (!std::is_arithmetic<_Up>::value &&
-            std::is_convertible<_Up, _Tp>::value) ||
-           std::is_same<__remove_const_t<_Up>, int>::value ||
-           (std::is_same<__remove_const_t<_Up>,
-                         unsigned int>::value &&
-            std::is_unsigned<_Tp>::value);
-  }
-
-  template <class _Generator, size_t... __indicies>
-  static constexpr decltype(
-      std::forward_as_tuple(std::declval<_Generator>()(
-          std::integral_constant<size_t, __indicies>())...),
-      bool())
-  __can_generate(std::index_sequence<__indicies...>) {
-    return !experimental::__variadic_sum<bool>(
-        !__can_broadcast<decltype(std::declval<_Generator>()(
-            std::integral_constant<size_t, __indicies>()))>()...);
-  }
-
-  template <class _Generator>
-  static bool __can_generate(...) {
-    return false;
-  }
-
-  template <class _Generator, size_t... __indicies>
-  void __generator_init(_Generator&& __g, std::index_sequence<__indicies...>) {
-    int __not_used[]{((*this)[__indicies] =
-                          __g(std::integral_constant<size_t, __indicies>()),
-                      0)...};
-    (void)__not_used;
-  }
-
-public:
-  // implicit type conversion constructor
-  template <class _Up,
-            class = typename std::enable_if<
-                std::is_same<_Abi, simd_abi::fixed_size<size()>>::value &&
-                __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()>::type>
-  simd(const simd<_Up, simd_abi::fixed_size<size()>>& __v) {
-    for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = static_cast<_Tp>(__v[__i]);
-    }
-  }
-
-  // implicit broadcast constructor
-  template <class _Up,
-            class = typename std::enable_if<__can_broadcast<_Up>()>::type>
-  simd(_Up&& __rv) {
-    auto __v = static_cast<_Tp>(__rv);
-    for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = __v;
-    }
-  }
-
-  // generator constructor
-  template <class _Generator,
-            int = typename std::enable_if<
-                __can_generate<_Generator>(std::make_index_sequence<size()>()),
-                int>::type()>
-  explicit simd(_Generator&& __g) {
-    __generator_init(std::forward<_Generator>(__g),
-                     std::make_index_sequence<size()>());
-  }
-
-  // load constructor
-  template <
-      class _Up, class _Flags,
-      class = typename std::enable_if<__vectorizable<_Up>()>::type,
-      class = typename std::enable_if<is_simd_flag_type<_Flags>::value>::type>
-  simd(const _Up* __buffer, _Flags) {
-    // TODO: optimize for overaligned flags
-    for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = static_cast<_Tp>(__buffer[__i]);
-    }
-  }
-
-  // loads [simd.load]
-  template <class _Up, class _Flags>
-  typename std::enable_if<__vectorizable<_Up>() &&
-                          is_simd_flag_type<_Flags>::value>::type
-  copy_from(const _Up* __buffer, _Flags) {
-    *this = simd(__buffer, _Flags());
-  }
+  static constexpr size_t size() noexcept { return simd_size_v<value_type, abi_type>; };
 
-  // stores [simd.store]
-  template <class _Up, class _Flags>
-  typename std::enable_if<__vectorizable<_Up>() &&
-                          is_simd_flag_type<_Flags>::value>::type
-  copy_to(_Up* __buffer, _Flags) const {
-    // TODO: optimize for overaligned flags
-    for (size_t __i = 0; __i < size(); __i++) {
-      __buffer[__i] = static_cast<_Up>((*this)[__i]);
-    }
-  }
+  simd() noexcept = default;
 
-  // scalar access [simd.subscr]
-  reference operator[](size_t __i) { return reference(&__s_, __i); }
+  // 9.6.4, simd constructors
+  template<class _Up, enable_if_t<__can_broadcast<value_type, _Up>(), int> = 0>
+    simd(_Up&& __value) noexcept;
+  template<class _Up> simd(const simd<_Up, simd_abi::fixed_size<size()>>&) noexcept;
+  template<class _Gen, enable_if_t<__can_generate<value_type, _Gen>(make_index_sequence<size()>()), int> = 0>
+    explicit simd(_Gen&& __gen) noexcept;
+  template<class _Up, class _Flags> simd(const _Up* __mem, _Flags);
+
+  // 9.6.5, simd copy functions
+  template<class _Up, class _Flags> void copy_from(const _Up* __mem, _Flags);
+  template<class _Up, class _Flags> void copy_to(_Up* __mem, _Flags);
 
-  value_type operator[](size_t __i) const { return __s_.__get(__i); }
+  // 9.6.6, simd subscript operators
+  reference operator[](size_t);
+  value_type operator[](size_t) const;
 
-  // unary operators [simd.unary]
-  simd& operator++();
-  simd operator++(int);
-  simd& operator--();
-  simd operator--(int);
-  mask_type operator!() const;
-  simd operator~() const;
-  simd operator+() const;
-  simd operator-() const;
-
-#if 0
-  // binary operators [simd.binary]
-  friend simd operator+(const simd&, const simd&);
-  friend simd operator-(const simd&, const simd&);
-  friend simd operator*(const simd&, const simd&);
-  friend simd operator/(const simd&, const simd&);
-  friend simd operator%(const simd&, const simd&);
-  friend simd operator&(const simd&, const simd&);
-  friend simd operator|(const simd&, const simd&);
-  friend simd operator^(const simd&, const simd&);
-  friend simd operator<<(const simd&, const simd&);
-  friend simd operator>>(const simd&, const simd&);
-  friend simd operator<<(const simd&, int);
-  friend simd operator>>(const simd&, int);
-
-  // compound assignment [simd.cassign]
-  friend simd& operator+=(simd&, const simd&);
-  friend simd& operator-=(simd&, const simd&);
-  friend simd& operator*=(simd&, const simd&);
-  friend simd& operator/=(simd&, const simd&);
-  friend simd& operator%=(simd&, const simd&);
-
-  friend simd& operator&=(simd&, const simd&);
-  friend simd& operator|=(simd&, const simd&);
-  friend simd& operator^=(simd&, const simd&);
-  friend simd& operator<<=(simd&, const simd&);
-  friend simd& operator>>=(simd&, const simd&);
-  friend simd& operator<<=(simd&, int);
-  friend simd& operator>>=(simd&, int);
-
-  // compares [simd.comparison]
-  friend mask_type operator==(const simd&, const simd&);
-  friend mask_type operator!=(const simd&, const simd&);
-  friend mask_type operator>=(const simd&, const simd&);
-  friend mask_type operator<=(const simd&, const simd&);
-  friend mask_type operator>(const simd&, const simd&);
-  friend mask_type operator<(const simd&, const simd&);
-#endif
+  // 9.6.7, simd unary operators
+  simd& operator++() noexcept;
+  simd operator++(int) noexcept;
+  simd& operator--() noexcept;
+  simd operator--(int) noexcept;
+  mask_type operator!() const noexcept;
+  simd operator~() const noexcept;
+  simd operator+() const noexcept;
+  simd operator-() const noexcept;
+
+  // 9.7.1, simd binary operators
+  friend simd operator+(const simd&, const simd&) noexcept;
+  friend simd operator-(const simd&, const simd&) noexcept;
+  friend simd operator*(const simd&, const simd&) noexcept;
+  friend simd operator/(const simd&, const simd&) noexcept;
+  friend simd operator%(const simd&, const simd&) noexcept;
+  friend simd operator&(const simd&, const simd&) noexcept;
+  friend simd operator|(const simd&, const simd&) noexcept;
+  friend simd operator^(const simd&, const simd&) noexcept;
+  friend simd operator<<(const simd&, const simd&) noexcept;
+  friend simd operator>>(const simd&, const simd&) noexcept;
+  friend simd operator<<(const simd&, int) noexcept;
+  friend simd operator>>(const simd&, int) noexcept;
+
+  // 9.7.2, simd compound assignment
+  friend simd& operator+=(simd&, const simd&) noexcept;
+  friend simd& operator-=(simd&, const simd&) noexcept;
+  friend simd& operator*=(simd&, const simd&) noexcept;
+  friend simd& operator/=(simd&, const simd&) noexcept;
+  friend simd& operator%=(simd&, const simd&) noexcept;
+  friend simd& operator&=(simd&, const simd&) noexcept;
+  friend simd& operator|=(simd&, const simd&) noexcept;
+  friend simd& operator^=(simd&, const simd&) noexcept;
+  friend simd& operator<<=(simd&, const simd&) noexcept;
+  friend simd& operator>>=(simd&, const simd&) noexcept;
+  friend simd& operator<<=(simd&, int) noexcept;
+  friend simd& operator>>=(simd&, int) noexcept;
+
+  // 9.7.3, simd compare operators
+  friend mask_type operator==(const simd&, const simd&) noexcept;
+  friend mask_type operator!=(const simd&, const simd&) noexcept;
+  friend mask_type operator>=(const simd&, const simd&) noexcept;
+  friend mask_type operator<=(const simd&, const simd&) noexcept;
+  friend mask_type operator>(const simd&, const simd&) noexcept;
+  friend mask_type operator<(const simd&, const simd&) noexcept;
 };
 
-// [simd.mask.class]
-template <class _Tp, class _Abi>
-// TODO: implement simd_mask
-class simd_mask {
+// 9.8, Class template simd_mask defination
+template<class _Tp, class _Abi> class simd_mask {
 public:
   using value_type = bool;
-  // TODO: this is strawman implementation. Turn it into a proxy type.
-  using reference = bool&;
+  using reference = __simd_reference<value_type>;
   using simd_type = simd<_Tp, _Abi>;
   using abi_type = _Abi;
-  static constexpr size_t size() noexcept;
-  simd_mask() = default;
 
-  // broadcast constructor
-  explicit simd_mask(value_type) noexcept;
+  static constexpr size_t size() noexcept { return simd_type::size(); };
+
+  simd_mask() noexcept = default;
 
-  // implicit type conversion constructor
-  template <class _Up>
+  // 9.8.3, Constructors
+  explicit simd_mask(value_type) noexcept;
+  template<class _Up>
     simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>&) noexcept;
+  template<class _Flags> simd_mask(const value_type* __mem, _Flags);
 
-  // load constructor
-  template <class _Flags>
-  simd_mask(const value_type*, _Flags);
-
-  // loads [simd.mask.copy]
-  template <class _Flags>
-  void copy_from(const value_type*, _Flags);
-  template <class _Flags>
-  void copy_to(value_type*, _Flags) const;
+  // 9.8.4, Copy functions
+  template<class _Flags> void copy_from(const value_type* __mem, _Flags);
+  template<class _Flags> void copy_to(value_type* __mem, _Flags);
 
-  // scalar access [simd.mask.subscr]
+  // 9.8.5, Subscript operators
   reference operator[](size_t);
   value_type operator[](size_t) const;
 
-  // unary operators [simd.mask.unary]
+  // 9.8.6, Unary operators
   simd_mask operator!() const noexcept;
 
-#if 0
-  // simd_mask binary operators [simd.mask.binary]
+  // 9.9.1, Binary operators
   friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator&(const simd_mask&, const simd_mask&)noexcept;
+  friend simd_mask operator&(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator|(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator^(const simd_mask&, const simd_mask&) noexcept;
 
-  // simd_mask compound assignment [simd.mask.cassign]
+  // 9.9.2, Compound assignment
   friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
   friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;
   friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
 
-  // simd_mask compares [simd.mask.comparison]
+  // 9.9.3, Comparisons
   friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
-#endif
 };
 
-#endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 
+#endif // _LIBCPP_STD_VER >= 17
+
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #endif
 
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */

libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.abi]
-
-#include <experimental/simd>
-#include <cstdint>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-constexpr inline int reg_width() {
-#if defined(__AVX__)
-  return 32;
-#else
-  return 16;
-#endif
-}
-
-#ifndef _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-static_assert(
-    sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 1>>) == 1,
-    "");
-static_assert(
-    sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 2>>) == 2,
-    "");
-static_assert(
-    sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) == 4,
-    "");
-static_assert(
-    sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 12>>) == 16,
-    "");
-static_assert(
-    sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) ==
-        16,
-    "");
-static_assert(
-    sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 5>>) ==
-        32,
-    "");
-static_assert(
-    std::is_same<ex::simd_abi::native<int8_t>,
-                 ex::__simd_abi<ex::_StorageKind::_VecExt, reg_width()>>::value,
-    "");
-#else
-static_assert(
-    std::is_same<ex::simd_abi::native<int8_t>,
-                 ex::__simd_abi<ex::_StorageKind::_Array, reg_width()>>::value,
-    "");
-
-#endif
-
-static_assert(std::is_same<ex::simd_abi::compatible<int8_t>,
-                           ex::__simd_abi<ex::_StorageKind::_Array, 16>>::value,
-              "");
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.access/default.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// scalar access [simd.subscr]
-// reference operator[](size_t);
-// value_type operator[](size_t) const;
-
-#include <experimental/simd>
-#include <cassert>
-#include <cstdint>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-template <typename SimdType>
-void test_access() {
-  {
-    SimdType a(42), b(4);
-    static_assert(std::is_convertible<decltype(a[0]), int8_t>::value, "");
-
-    assert(a[0] == 42);
-    assert(!a[0] == !42);
-    assert(~a[0] == ~42);
-    assert(+a[0] == +42);
-    assert(-a[0] == -42);
-    assert(a[0] + b[0] == 42 + 4);
-    assert(a[0] - b[0] == 42 - 4);
-    assert(a[0] * b[0] == 42 * 4);
-    assert(a[0] / b[0] == 42 / 4);
-    assert(a[0] % b[0] == 42 % 4);
-    assert(a[0] << b[0] == (42 << 4));
-    assert(a[0] >> b[0] == (42 >> 4));
-    assert((a[0] < b[0]) == false);
-    assert((a[0] <= b[0]) == false);
-    assert((a[0] > b[0]) == true);
-    assert((a[0] >= b[0]) == true);
-    assert((a[0] == b[0]) == false);
-    assert((a[0] != b[0]) == true);
-    assert((a[0] & b[0]) == (42 & 4));
-    assert((a[0] | b[0]) == (42 | 4));
-    assert((a[0] ^ b[0]) == (42 ^ 4));
-    assert((a[0] && b[0]) == true);
-    assert((a[0] || b[0]) == true);
-
-    {
-      auto c = a;
-      ++c[0];
-      assert(c[0] == 42 + 1);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      auto ret = c[0]++;
-      assert(ret == 42);
-      assert(c[0] == 42 + 1);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      --c[0];
-      assert(c[0] == 42 - 1);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      auto ret = c[0]--;
-      assert(ret == 42);
-      assert(c[0] == 42 - 1);
-      assert(c[1] == 42);
-    }
-
-    {
-      auto c = a;
-      c[0] += b[0];
-      assert(c[0] == 42 + 4);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] -= b[0];
-      assert(c[0] == 42 - 4);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] *= b[0];
-      assert(c[0] == 42 * 4);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] /= b[0];
-      assert(c[0] == 42 / 4);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] %= b[0];
-      assert(c[0] == 42 % 4);
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] >>= b[0];
-      assert(c[0] == (42 >> 4));
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] <<= b[0];
-      assert(c[0] == (42 << 4));
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] &= b[0];
-      assert(c[0] == (42 & 4));
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] |= b[0];
-      assert(c[0] == (42 | 4));
-      assert(c[1] == 42);
-    }
-    {
-      auto c = a;
-      c[0] ^= b[0];
-      assert(c[0] == (42 ^ 4));
-      assert(c[1] == 42);
-    }
-
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] += a[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] -= a[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] *= a[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] /= a[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] %= a[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] >>= b[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] <<= b[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] &= a[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] |= a[0]));
-    }
-    {
-      auto c = a;
-      (void)(a[0] + (c[0] ^= a[0]));
-    }
-  }
-  {
-    const SimdType a(42);
-    const SimdType b(4);
-    static_assert(std::is_same<decltype(a[0]), int>::value, "");
-
-    assert(a[0] == 42);
-    assert(!a[0] == !42);
-    assert(~a[0] == ~42);
-    assert(+a[0] == +42);
-    assert(-a[0] == -42);
-    assert(a[0] + b[0] == 42 + 4);
-    assert(a[0] - b[0] == 42 - 4);
-    assert(a[0] * b[0] == 42 * 4);
-    assert(a[0] / b[0] == 42 / 4);
-    assert(a[0] % b[0] == 42 % 4);
-    assert(a[0] << b[0] == (42 << 4));
-    assert(a[0] >> b[0] == (42 >> 4));
-    assert((a[0] < b[0]) == false);
-    assert((a[0] <= b[0]) == false);
-    assert((a[0] > b[0]) == true);
-    assert((a[0] >= b[0]) == true);
-    assert((a[0] == b[0]) == false);
-    assert((a[0] != b[0]) == true);
-    assert((a[0] & b[0]) == (42 & 4));
-    assert((a[0] | b[0]) == (42 | 4));
-    assert((a[0] ^ b[0]) == (42 ^ 4));
-    assert((a[0] && b[0]) == true);
-    assert((a[0] || b[0]) == true);
-  }
-}
-
-int main(int, char**) {
-  test_access<ex::native_simd<int>>();
-  test_access<ex::fixed_size_simd<int, 4>>();
-
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.casts]
-// template <class T, class U, class Abi> see below ex::simd_cast<(const
-// ex::simd<U, Abi>&);
-
-#include <experimental/simd>
-#include <cstdint>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-static_assert(
-    std::is_same<decltype(ex::simd_cast<int32_t>(ex::native_simd<int32_t>())),
-                 ex::native_simd<int32_t>>::value,
-    "");
-
-static_assert(std::is_same<decltype(ex::simd_cast<int64_t>(
-                               ex::fixed_size_simd<int32_t, 4>())),
-                           ex::fixed_size_simd<int64_t, 4>>::value,
-              "");
-
-static_assert(
-    std::is_same<decltype(ex::simd_cast<ex::fixed_size_simd<int64_t, 1>>(
-                     ex::simd<int32_t, ex::simd_abi::scalar>())),
-                 ex::fixed_size_simd<int64_t, 1>>::value,
-    "");
-
-static_assert(
-    std::is_same<
-        decltype(ex::simd_cast<ex::simd<int64_t, ex::simd_abi::scalar>>(
-            ex::fixed_size_simd<int32_t, 1>())),
-        ex::simd<int64_t, ex::simd_abi::scalar>>::value,
-    "");
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.casts]
-// template <class T, class U, class Abi> see below ex::static_simd_cast<(const
-// ex::simd<U, Abi>&);
-
-#include <experimental/simd>
-#include <cstdint>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-static_assert(
-    std::is_same<decltype(ex::static_simd_cast<float>(ex::native_simd<int>())),
-                 ex::native_simd<float>>::value,
-    "");
-
-static_assert(
-    std::is_same<decltype(ex::static_simd_cast<ex::fixed_size_simd<float, 1>>(
-                     ex::simd<int, ex::simd_abi::scalar>())),
-                 ex::fixed_size_simd<float, 1>>::value,
-    "");
-
-static_assert(
-    std::is_same<
-        decltype(ex::static_simd_cast<ex::simd<float, ex::simd_abi::scalar>>(
-            ex::fixed_size_simd<int, 1>())),
-        ex::simd<float, ex::simd_abi::scalar>>::value,
-    "");
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.class/simd_width.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.class]
+// static constexpr size_t size() noexcept;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+struct CheckSimdWidth {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    const ex::simd<_Tp, SimdAbi> origin_simd{};
+    static_assert(origin_simd.size() == ex::simd_size_v<_Tp, SimdAbi>);
+  }
+};
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  F{}.template operator()<_Tp, SimdAbi>();
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckSimdWidth>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.class]
-// template <class U> simd(U&& value);
-
-#include <experimental/simd>
-#include <cstdint>
-#include <cassert>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-template <class T, class... Args>
-auto not_supported_native_simd_ctor(Args&&... args)
-    -> decltype(ex::native_simd<T>(std::forward<Args>(args)...),
-                void()) = delete;
-
-template <class T>
-void not_supported_native_simd_ctor(...) {}
-
-template <class T, class... Args>
-auto supported_native_simd_ctor(Args&&... args)
-    -> decltype(ex::native_simd<T>(std::forward<Args>(args)...), void()) {}
-
-template <class T>
-void supported_native_simd_ctor(...) = delete;
-
-void compile_narrowing_conversion() {
-  supported_native_simd_ctor<int8_t>(3);
-  supported_native_simd_ctor<int16_t>(3);
-  supported_native_simd_ctor<int32_t>(3);
-  supported_native_simd_ctor<int64_t>(3);
-  supported_native_simd_ctor<uint8_t>(3);
-  supported_native_simd_ctor<uint16_t>(3);
-  supported_native_simd_ctor<uint32_t>(3);
-  supported_native_simd_ctor<uint64_t>(3);
-  supported_native_simd_ctor<float>(3.f);
-  supported_native_simd_ctor<double>(3.);
-  supported_native_simd_ctor<long double>(3.);
-
-  not_supported_native_simd_ctor<float>(3.);
-  not_supported_native_simd_ctor<int8_t>(long(3));
-  not_supported_native_simd_ctor<float>(long(3));
-  not_supported_native_simd_ctor<int>(3.);
-}
-
-void compile_convertible() {
-  struct ConvertibleToInt {
-    operator int64_t() const;
-  };
-  supported_native_simd_ctor<int64_t>(ConvertibleToInt());
-
-  struct NotConvertibleToInt {};
-  not_supported_native_simd_ctor<int64_t>(NotConvertibleToInt());
-}
-
-void compile_unsigned() {
-  not_supported_native_simd_ctor<int>(3u);
-  supported_native_simd_ctor<uint16_t>(3u);
-}
-
-template <typename SimdType>
-void test_broadcast() {
-  SimdType a(3);
-  for (size_t i = 0; i < a.size(); i++) {
-    assert(a[i] == 3);
-  }
-}
-
-int main(int, char**) {
-  test_broadcast<ex::native_simd<int>>();
-  test_broadcast<ex::fixed_size_simd<int, 4>>();
-  test_broadcast<ex::fixed_size_simd<int, 15>>();
-
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.class]
-// simd() = default;
-
-#include <cstdint>
-#include <experimental/simd>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-int main(int, char**) {
-  static_assert(ex::native_simd<int32_t>().size() > 0, "");
-  static_assert(ex::fixed_size_simd<int32_t, 4>().size() == 4, "");
-  static_assert(ex::fixed_size_simd<int32_t, 5>().size() == 5, "");
-  static_assert(ex::fixed_size_simd<int32_t, 1>().size() == 1, "");
-  static_assert(ex::fixed_size_simd<char, 32>().size() == 32, "");
-
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.class]
-// template <class G> explicit simd(G&& gen);
-
-#include <experimental/simd>
-#include <cstdint>
-#include <cassert>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-template <class T, class... Args>
-auto not_supported_simd128_ctor(Args&&... args) -> decltype(
-    ex::fixed_size_simd<T, 16 / sizeof(T)>(std::forward<Args>(args)...),
-    void()) = delete;
-
-template <class T>
-void not_supported_simd128_ctor(...) {}
-
-template <class T, class... Args>
-auto supported_simd128_ctor(Args&&... args) -> decltype(
-    ex::fixed_size_simd<T, 16 / sizeof(T)>(std::forward<Args>(args)...),
-    void()) {}
-
-template <class T>
-void supported_simd128_ctor(...) = delete;
-
-struct identity {
-  template <size_t value>
-  int operator()(std::integral_constant<size_t, value>) const {
-    return value;
-  }
-};
-
-void compile_generator() {
-  supported_simd128_ctor<int>(identity());
-  not_supported_simd128_ctor<int>([](int i) { return float(i); });
-  not_supported_simd128_ctor<int>([](intptr_t i) { return (int*)(i); });
-  not_supported_simd128_ctor<int>([](int* i) { return i; });
-}
-
-struct limited_identity {
-  template <size_t value>
-  typename std::conditional<value <= 2, int32_t, int64_t>::type
-  operator()(std::integral_constant<size_t, value>) const {
-    return value;
-  }
-};
-
-void compile_limited_identity() {
-  supported_simd128_ctor<int64_t>(limited_identity());
-  not_supported_simd128_ctor<int32_t>(limited_identity());
-}
-
-template <typename SimdType>
-void test_generator() {
-  {
-    SimdType a([](int i) { return i; });
-    assert(a[0] == 0);
-    assert(a[1] == 1);
-    assert(a[2] == 2);
-    assert(a[3] == 3);
-  }
-  {
-    SimdType a([](int i) { return 2 * i - 1; });
-    assert(a[0] == -1);
-    assert(a[1] == 1);
-    assert(a[2] == 3);
-    assert(a[3] == 5);
-  }
-}
-
-int main(int, char**) {
-  // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_generator<ex::native_simd<int32_t>>();
-  test_generator<ex::fixed_size_simd<int32_t, 4>>();
-
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.class]
-// template <class U, class Flags> simd(const U* mem, Flags f);
-
-#include <experimental/simd>
-#include <cstdint>
-#include <cassert>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-template <class T, class... Args>
-auto not_supported_native_simd_ctor(Args&&... args)
-    -> decltype(ex::native_simd<T>(std::forward<Args>(args)...),
-                void()) = delete;
-
-template <class T>
-void not_supported_native_simd_ctor(...) {}
-
-template <class T, class... Args>
-auto supported_native_simd_ctor(Args&&... args)
-    -> decltype(ex::native_simd<T>(std::forward<Args>(args)...), void()) {}
-
-template <class T>
-void supported_native_simd_ctor(...) = delete;
-
-void compile_load_ctor() {
-  supported_native_simd_ctor<int>((int*)nullptr, ex::element_aligned_tag());
-  supported_native_simd_ctor<uint32_t>((int*)nullptr,
-                                       ex::element_aligned_tag());
-  supported_native_simd_ctor<double>((float*)nullptr,
-                                     ex::element_aligned_tag());
-  supported_native_simd_ctor<uint16_t>((unsigned int*)nullptr,
-                                       ex::element_aligned_tag());
-  supported_native_simd_ctor<uint32_t>((float*)nullptr,
-                                       ex::element_aligned_tag());
-
-  not_supported_native_simd_ctor<int>((int*)nullptr, int());
-}
-
-template <typename SimdType>
-void test_load_ctor() {
-  alignas(32) int32_t buffer[] = {4, 3, 2, 1};
-  {
-    SimdType a(buffer, ex::element_aligned_tag());
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a(buffer, ex::vector_aligned_tag());
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a(buffer, ex::overaligned_tag<32>());
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-
-  {
-    SimdType a(buffer, ex::element_aligned);
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a(buffer, ex::vector_aligned);
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a(buffer, ex::overaligned<32>);
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-}
-
-template <typename SimdType>
-void test_converting_load_ctor() {
-  float buffer[] = {1., 2., 4., 8.};
-  SimdType a(buffer, ex::element_aligned_tag());
-  assert(a[0] == 1);
-  assert(a[1] == 2);
-  assert(a[2] == 4);
-  assert(a[3] == 8);
-}
-
-int main(int, char**) {
-  // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_load_ctor<ex::native_simd<int32_t>>();
-  test_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_load_ctor<ex::native_simd<int32_t>>();
-  test_converting_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
-
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.mask.class/simd_mask_width.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.mask.class]
+// static constexpr size_t size() noexcept;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+struct CheckSimdMaskWidth {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    const ex::simd_mask<_Tp, SimdAbi> origin_simd_mask{};
+    static_assert(origin_simd_mask.size() == ex::simd_size_v<_Tp, SimdAbi>);
+  }
+};
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  F{}.template operator()<_Tp, SimdAbi>();
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckSimdMaskWidth>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// loads [simd.load]
-// template <class U, class Flags> void copy_from(const U* mem, Flags f);
-
-#include <experimental/simd>
-#include <cstdint>
-#include <cassert>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-template <class T, class... Args>
-auto not_supported_load(Args&&... args) -> decltype(
-    std::declval<ex::native_simd<T>>().copy_from(std::forward<Args>(args)...),
-    void()) = delete;
-
-template <class T>
-void not_supported_load(...) {}
-
-template <class T, class... Args>
-auto supported_load(Args&&... args) -> decltype(
-    std::declval<ex::native_simd<T>>().copy_from(std::forward<Args>(args)...),
-    void()) {}
-
-template <class T>
-void supported_load(...) = delete;
-
-void compile_load() {
-  supported_load<int>((int*)nullptr, ex::element_aligned_tag());
-  supported_load<uint32_t>((int*)nullptr, ex::element_aligned_tag());
-  supported_load<double>((float*)nullptr, ex::element_aligned_tag());
-  supported_load<uint16_t>((unsigned int*)nullptr, ex::element_aligned_tag());
-  supported_load<uint32_t>((float*)nullptr, ex::element_aligned_tag());
-
-  not_supported_load<int>((int*)nullptr, int());
-}
-
-template <typename SimdType>
-void test_load() {
-  alignas(32) int32_t buffer[] = {4, 3, 2, 1};
-  {
-    SimdType a;
-    a.copy_from(buffer, ex::element_aligned_tag());
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a;
-    a.copy_from(buffer, ex::vector_aligned_tag());
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a;
-    a.copy_from(buffer, ex::overaligned_tag<32>());
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-
-  {
-    SimdType a;
-    a.copy_from(buffer, ex::element_aligned);
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a;
-    a.copy_from(buffer, ex::vector_aligned);
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-  {
-    SimdType a;
-    a.copy_from(buffer, ex::overaligned<32>);
-    assert(a[0] == 4);
-    assert(a[1] == 3);
-    assert(a[2] == 2);
-    assert(a[3] == 1);
-  }
-}
-
-template <typename SimdType>
-void test_converting_load() {
-  float buffer[] = {1., 2., 4., 8.};
-  SimdType a;
-  a.copy_from(buffer, ex::element_aligned_tag());
-  assert(a[0] == 1);
-  assert(a[1] == 2);
-  assert(a[2] == 4);
-  assert(a[3] == 8);
-}
-
-int main(int, char**) {
-  // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_load<ex::native_simd<int32_t>>();
-  test_load<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_load<ex::native_simd<int32_t>>();
-  test_converting_load<ex::fixed_size_simd<int32_t, 4>>();
-
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// // stores [simd.store]
-// template <class U, class Flags> void copy_to(U* mem, Flags f) const;
-
-#include <experimental/simd>
-#include <cstdint>
-#include <cassert>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-template <typename SimdType>
-void test_store() {
-  SimdType a([](int i) { return 4 - i; });
-  {
-    alignas(32) int32_t buffer[4] = {0};
-    a.copy_to(buffer, ex::element_aligned_tag());
-    assert(buffer[0] == 4);
-    assert(buffer[1] == 3);
-    assert(buffer[2] == 2);
-    assert(buffer[3] == 1);
-  }
-  {
-    alignas(32) int32_t buffer[4] = {0};
-    a.copy_to(buffer, ex::vector_aligned_tag());
-    assert(buffer[0] == 4);
-    assert(buffer[1] == 3);
-    assert(buffer[2] == 2);
-    assert(buffer[3] == 1);
-  }
-  {
-    alignas(32) int32_t buffer[4] = {0};
-    a.copy_to(buffer, ex::overaligned_tag<32>());
-    assert(buffer[0] == 4);
-    assert(buffer[1] == 3);
-    assert(buffer[2] == 2);
-    assert(buffer[3] == 1);
-  }
-
-  {
-    alignas(32) int32_t buffer[4] = {0};
-    a.copy_to(buffer, ex::element_aligned);
-    assert(buffer[0] == 4);
-    assert(buffer[1] == 3);
-    assert(buffer[2] == 2);
-    assert(buffer[3] == 1);
-  }
-  {
-    alignas(32) int32_t buffer[4] = {0};
-    a.copy_to(buffer, ex::vector_aligned);
-    assert(buffer[0] == 4);
-    assert(buffer[1] == 3);
-    assert(buffer[2] == 2);
-    assert(buffer[3] == 1);
-  }
-  {
-    alignas(32) int32_t buffer[4] = {0};
-    a.copy_to(buffer, ex::overaligned<32>);
-    assert(buffer[0] == 4);
-    assert(buffer[1] == 3);
-    assert(buffer[2] == 2);
-    assert(buffer[3] == 1);
-  }
-}
-
-template <typename SimdType>
-void test_converting_store() {
-  float buffer[4] = {0.};
-  SimdType a([](int i) { return 1 << i; });
-  a.copy_to(buffer, ex::element_aligned_tag());
-  assert(buffer[0] == 1.);
-  assert(buffer[1] == 2.);
-  assert(buffer[2] == 4.);
-  assert(buffer[3] == 8.);
-}
-
-int main(int, char**) {
-  // TODO: adjust the tests when this assertion fails.
-  test_store<ex::native_simd<int32_t>>();
-  test_store<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_store<ex::native_simd<int32_t>>();
-  test_converting_store<ex::fixed_size_simd<int32_t, 4>>();
-
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.traits]
-// template <class T, size_t N> struct abi_for_size { using type = see below ;
-// }; template <class T, size_t N> using ex::abi_for_size_t = typename
-// ex::abi_for_size<T, N>::type;
-
-#include <cstdint>
-#include <experimental/simd>
-
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-static_assert(std::is_same<typename ex::abi_for_size<int, 4>::type,
-                           ex::simd_abi::fixed_size<4>>::value,
-              "");
-
-static_assert(std::is_same<ex::abi_for_size_t<int, 4>,
-                           ex::simd_abi::fixed_size<4>>::value,
-              "");
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <experimental/simd>
 //
 // [simd.traits]
 // template <class T> struct is_abi_tag;
-// template <class T> inline constexpr bool ex::is_abi_tag_v =
-// ex::is_abi_tag<T>::value;
+// template <class T> inline constexpr bool ex::is_abi_tag_v = ex::is_abi_tag<T>::value;
 
+#include "../test_utils.h"
 #include <cstdint>
 #include <experimental/simd>
-#include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
-struct UserType {};
+struct CheckIsAbiTagTrue {
+  template <class _Tp>
+  void operator()() {
+    static_assert(_Tp::value);
+  }
+};
+
+struct CheckIsAbiTagFalse {
+  template <class _Tp>
+  void operator()() {
+    static_assert(!_Tp::value);
+  }
+};
+
+struct CheckIsAbiTagVTrue {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(_Tp);
+  }
+};
 
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int64_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint64_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<float>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<double>>::value, "");
-
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int64_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint64_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<float>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<double>>::value, "");
-
-static_assert(ex::is_abi_tag<ex::simd_abi::scalar>::value, "");
-static_assert(
-    !std::is_same<ex::simd_abi::scalar, ex::simd_abi::fixed_size<1>>::value,
-    "");
-
-static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<1>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<2>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<3>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<4>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<5>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<32>>::value, "");
-
-static_assert(!ex::is_abi_tag<void>::value, "");
-static_assert(!ex::is_abi_tag<int>::value, "");
-static_assert(!ex::is_abi_tag<float>::value, "");
-static_assert(!ex::is_abi_tag<UserType>::value, "");
-static_assert(!ex::is_abi_tag<ex::simd<int>>::value, "");
-static_assert(!ex::is_abi_tag<ex::simd<float>>::value, "");
-static_assert(!ex::is_abi_tag<ex::simd_mask<int>>::value, "");
-static_assert(!ex::is_abi_tag<ex::simd_mask<float>>::value, "");
-
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int64_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint64_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<float>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<double>>, "");
-
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int64_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint64_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<float>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<double>>, "");
-
-static_assert(ex::is_abi_tag_v<ex::simd_abi::scalar>, "");
-static_assert(
-    !std::is_same<ex::simd_abi::scalar, ex::simd_abi::fixed_size<1>>::value,
-    "");
-
-static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<1>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<2>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<3>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<4>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<5>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<32>>, "");
-
-static_assert(!ex::is_abi_tag_v<void>, "");
-static_assert(!ex::is_abi_tag_v<int>, "");
-static_assert(!ex::is_abi_tag_v<float>, "");
-static_assert(!ex::is_abi_tag_v<UserType>, "");
-static_assert(!ex::is_abi_tag_v<ex::simd<int>>, "");
-static_assert(!ex::is_abi_tag_v<ex::simd<float>>, "");
-static_assert(!ex::is_abi_tag_v<ex::simd_mask<int>>, "");
-static_assert(!ex::is_abi_tag_v<ex::simd_mask<float>>, "");
+struct CheckIsAbiTagVFalse {
+  template <bool _Tp>
+  void operator()() {
+    static_assert(!_Tp);
+  }
+};
+
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  if constexpr (std::is_same<F, CheckIsAbiTagTrue>::value) {
+    F{}.template operator()<ex::is_abi_tag<SimdAbi>>();
+  } else if constexpr (std::is_same<F, CheckIsAbiTagFalse>::value) {
+    F{}.template operator()<ex::is_abi_tag<_Tp>>();
+    F{}.template operator()<ex::is_abi_tag<ex::simd<_Tp, SimdAbi>>>();
+    F{}.template operator()<ex::is_abi_tag<ex::simd_mask<_Tp, SimdAbi>>>();
+  } else if constexpr (std::is_same<F, CheckIsAbiTagVTrue>::value) {
+    F{}.template operator()<ex::is_abi_tag_v<SimdAbi>>();
+  } else {
+    F{}.template operator()<ex::is_abi_tag_v<_Tp>>();
+    F{}.template operator()<ex::is_abi_tag_v<ex::simd<_Tp, SimdAbi>>>();
+    F{}.template operator()<ex::is_abi_tag_v<ex::simd_mask<_Tp, SimdAbi>>>();
+  }
+
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
 
 int main(int, char**) {
+  test_all_simd_abi<CheckIsAbiTagTrue>();
+  test_all_simd_abi<CheckIsAbiTagFalse>();
+  test_all_simd_abi<CheckIsAbiTagVTrue>();
+  test_all_simd_abi<CheckIsAbiTagVFalse>();
   return 0;
 }

libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.traits]
-// template <class T> struct ex::is_simd;
-// template <class T> inline constexpr bool ex::is_simd_v =
-// ex::is_simd<T>::value;
-
-#include <cstdint>
-#include <experimental/simd>
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-struct UserType {};
-
-static_assert(ex::is_simd<ex::native_simd<int8_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<int16_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<int32_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<int64_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint8_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint16_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint32_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint64_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<float>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<double>>::value, "");
-
-static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<float, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<double, 1>>::value, "");
-
-static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<float, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<double, 3>>::value, "");
-
-static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<float, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<double, 32>>::value, "");
-
-static_assert(!ex::is_simd<void>::value, "");
-static_assert(!ex::is_simd<int>::value, "");
-static_assert(!ex::is_simd<float>::value, "");
-static_assert(!ex::is_simd<ex::simd_mask<int>>::value, "");
-static_assert(!ex::is_simd<ex::simd_mask<float>>::value, "");
-static_assert(!ex::is_simd<UserType>::value, "");
-
-static_assert(ex::is_simd_v<ex::native_simd<int8_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<int16_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<int32_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<int64_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint8_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint16_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint32_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint64_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<float>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<double>>, "");
-
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 1>>, "");
-
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 3>>, "");
-
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 32>>, "");
-
-static_assert(!ex::is_simd_v<void>, "");
-static_assert(!ex::is_simd_v<int>, "");
-static_assert(!ex::is_simd_v<float>, "");
-static_assert(!ex::is_simd_v<ex::simd_mask<int>>, "");
-static_assert(!ex::is_simd_v<ex::simd_mask<float>>, "");
-static_assert(!ex::is_simd_v<UserType>, "");
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.traits]
-// template <class T> struct is_simd_flag_type;
-// template <class T> inline constexpr bool ex::is_simd_flag_type_v =
-// ex::is_simd_flag_type<T>::value;
-
-#include <cstdint>
-#include <experimental/simd>
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-struct UserType {};
-
-static_assert(ex::is_simd_flag_type<ex::element_aligned_tag>::value, "");
-static_assert(ex::is_simd_flag_type<ex::vector_aligned_tag>::value, "");
-static_assert(ex::is_simd_flag_type<ex::overaligned_tag<16>>::value, "");
-static_assert(ex::is_simd_flag_type<ex::overaligned_tag<32>>::value, "");
-
-static_assert(!ex::is_simd_flag_type<void>::value, "");
-static_assert(!ex::is_simd_flag_type<int>::value, "");
-static_assert(!ex::is_simd_flag_type<float>::value, "");
-static_assert(!ex::is_simd_flag_type<UserType>::value, "");
-static_assert(!ex::is_simd_flag_type<ex::simd<int8_t>>::value, "");
-static_assert(!ex::is_simd_flag_type<ex::simd_mask<int8_t>>::value, "");
-
-static_assert(ex::is_simd_flag_type_v<ex::element_aligned_tag>, "");
-static_assert(ex::is_simd_flag_type_v<ex::vector_aligned_tag>, "");
-static_assert(ex::is_simd_flag_type_v<ex::overaligned_tag<16>>, "");
-static_assert(ex::is_simd_flag_type_v<ex::overaligned_tag<32>>, "");
-
-static_assert(!ex::is_simd_flag_type_v<void>, "");
-static_assert(!ex::is_simd_flag_type_v<int>, "");
-static_assert(!ex::is_simd_flag_type_v<float>, "");
-static_assert(!ex::is_simd_flag_type_v<UserType>, "");
-static_assert(!ex::is_simd_flag_type_v<ex::simd<int8_t>>, "");
-static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<int8_t>>, "");
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14
-
-// <experimental/simd>
-//
-// [simd.traits]
-// template <class T> struct ex::is_simd_mask;
-// template <class T> inline constexpr bool ex::is_simd_mask_v =
-// ex::is_simd_mask<T>::value;
-
-#include <cstdint>
-#include <experimental/simd>
-#include "test_macros.h"
-
-namespace ex = std::experimental::parallelism_v2;
-
-struct UserType {};
-
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int8_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int16_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int32_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int64_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint8_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint16_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint32_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint64_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<float>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<double>>::value, "");
-
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 1>>::value, "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 1>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 1>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 1>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 1>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 1>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 1>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 1>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 1>>::value, "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 1>>::value, "");
-
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 3>>::value, "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 3>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 3>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 3>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 3>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 3>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 3>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 3>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 3>>::value, "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 3>>::value, "");
-
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 32>>::value,
-              "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 32>>::value, "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 32>>::value,
-              "");
-
-static_assert(!ex::is_simd_mask<void>::value, "");
-static_assert(!ex::is_simd_mask<int>::value, "");
-static_assert(!ex::is_simd_mask<float>::value, "");
-static_assert(!ex::is_simd_mask<ex::simd<int>>::value, "");
-static_assert(!ex::is_simd_mask<ex::simd<float>>::value, "");
-static_assert(!ex::is_simd_mask<UserType>::value, "");
-
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int8_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int16_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int32_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int64_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint8_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint16_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint32_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint64_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<float>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<double>>, "");
-
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 1>>, "");
-
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 3>>, "");
-
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 32>>, "");
-
-static_assert(!ex::is_simd_mask_v<void>, "");
-static_assert(!ex::is_simd_mask_v<int>, "");
-static_assert(!ex::is_simd_mask_v<float>, "");
-static_assert(!ex::is_simd_mask_v<ex::simd<int>>, "");
-static_assert(!ex::is_simd_mask_v<ex::simd<float>>, "");
-static_assert(!ex::is_simd_mask_v<UserType>, "");
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/experimental/simd/simd.traits/simd_size.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.traits]
+//template <class T, class Abi = simd_abi::compatible<T>> struct simd_size;
+//template <class T, class Abi = simd_abi::compatible<T>>
+//inline constexpr size_t ex::simd_size_v = ex::simd_size<T, Abi>::value;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckSimdSizeDeduce {
+  template <class _Tp, size_t _Np, class SimdAbi = ex::simd_abi::deduce_t<_Tp, _Np>>
+  void operator()() {
+    static_assert(ex::simd_size<_Tp, SimdAbi>::value == _Np);
+  };
+};
+struct CheckSimdSizeVDeduce {
+  template <class _Tp, size_t _Np, class SimdAbi = ex::simd_abi::deduce_t<_Tp, _Np>>
+  void operator()() {
+    static_assert(ex::simd_size_v<_Tp, SimdAbi> == _Np);
+  };
+};
+struct CheckSimdSizeFixedSize {
+  template <class _Tp, size_t _Np, class SimdAbi = ex::simd_abi::fixed_size<_Np>>
+  void operator()() {
+    static_assert(ex::simd_size<_Tp, SimdAbi>::value == _Np);
+  };
+};
+struct CheckSimdSizeVFixedSize {
+  template <class _Tp, size_t _Np, class SimdAbi = ex::simd_abi::fixed_size<_Np>>
+  void operator()() {
+    static_assert(ex::simd_size_v<_Tp, SimdAbi> == _Np);
+  };
+};
+
+struct CheckSimdSizeScalar {
+  template <class _Tp, class SimdAbi = ex::simd_abi::scalar>
+  void operator()() {
+    static_assert(ex::simd_size<_Tp, SimdAbi>::value == 1);
+  };
+};
+struct CheckSimdSizeVScalar {
+  template <class _Tp, class SimdAbi = ex::simd_abi::scalar>
+  void operator()() {
+    static_assert(ex::simd_size_v<_Tp, SimdAbi> == 1);
+  };
+};
+struct CheckSimdSizeCompatible {
+  template <class _Tp, class SimdAbi = ex::simd_abi::compatible<_Tp>>
+  void operator()() {
+    static_assert(ex::simd_size<_Tp, SimdAbi>::value == 16 / sizeof(_Tp));
+  };
+};
+struct CheckSimdSizeVCompatible {
+  template <class _Tp, class SimdAbi = ex::simd_abi::compatible<_Tp>>
+  void operator()() {
+    static_assert(ex::simd_size_v<_Tp, SimdAbi> == 16 / sizeof(_Tp));
+  };
+};
+
+struct CheckSimdSizeNative {
+  template <class _Tp, class SimdAbi = ex::simd_abi::native<_Tp>>
+  void operator()() {
+    static_assert(ex::simd_size<_Tp, SimdAbi>::value == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp));
+  };
+};
+struct CheckSimdSizeVNative {
+  template <class _Tp, class SimdAbi = ex::simd_abi::native<_Tp>>
+  void operator()() {
+    static_assert(ex::simd_size_v<_Tp, SimdAbi> == _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp));
+  };
+};
+
+template <class F, std::size_t _Np, class _Tp>
+void test_simd_abi() {}
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi() {
+  if constexpr (std::is_same<F, CheckSimdSizeDeduce>::value || std::is_same<F, CheckSimdSizeVDeduce>::value ||
+                std::is_same<F, CheckSimdSizeFixedSize>::value || std::is_same<F, CheckSimdSizeVFixedSize>::value) {
+    F{}.template operator()<_Tp, _Np>();
+  } else {
+    F{}.template operator()<_Tp>();
+  }
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckSimdSizeDeduce>();
+  test_all_simd_abi<CheckSimdSizeVDeduce>();
+
+  test_all_simd_abi<CheckSimdSizeFixedSize>();
+  test_all_simd_abi<CheckSimdSizeVFixedSize>();
+
+  test_all_simd_abi<CheckSimdSizeScalar>();
+  test_all_simd_abi<CheckSimdSizeVScalar>();
+
+  test_all_simd_abi<CheckSimdSizeCompatible>();
+  test_all_simd_abi<CheckSimdSizeVCompatible>();
+
+  test_all_simd_abi<CheckSimdSizeNative>();
+  test_all_simd_abi<CheckSimdSizeVNative>();
+
+  return 0;
+}

libcxx/test/std/experimental/simd/test_utils.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_UTIL_H
+#define TEST_UTIL_H
+
+#include <cassert>
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <class F, std::size_t _Np, class _Tp, class SimdAbi, class... SimdAbis>
+void test_simd_abi();
+
+template <class F, class _Tp, std::size_t... _Np>
+void test_all_simd_abi(std::integer_sequence<std::size_t, _Np...>) {
+  using namespace ex;
+
+  (test_simd_abi<F,
+                 _Np + 1,
+                 _Tp,
+                 simd_abi::native<_Tp>,
+                 simd_abi::fixed_size<_Np + 1>,
+                 simd_abi::scalar,
+                 simd_abi::compatible<_Tp>,
+                 simd_abi::deduce_t<_Tp, _Np + 1>>(),
+   ...);
+}
+
+template <class F>
+void test_all_simd_abi() {
+  constexpr auto integer_seq_from_make_integer = std::make_integer_sequence<size_t, 31>();
+  test_all_simd_abi<F, long double>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, double>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, float>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, long long>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, unsigned long long>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, long>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, unsigned long>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, int>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, unsigned int>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, short>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, unsigned short>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, wchar_t>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, signed char>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, unsigned char>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, char32_t>(integer_seq_from_make_integer);
+  test_all_simd_abi<F, char16_t>(integer_seq_from_make_integer);
+}
+#endif // TEST_UTIL_H