[libcxx] <experimental/simd> Added internal storage type, constructors, subscript operators of class simd/simd_mask and related tests

[Joy12138]

Summary

[libcxx] <experimental/simd> Added internal storage type for class simd/simd_mask
[libcxx] <experimental/simd> Added all constructors of class simd/simd_mask and related tests
[libcxx] <experimental/simd> Added basic simd reference implementation, subscript operators of class simd/simd_mask and related tests

[Mordante]

I mainly look quickly over the patch, can you get the patch to apply properly so the CI can test it?

libcxx/include/experimental/__simd/utility.h

98

Will the compiler optimize this?
Since a bool has two values it might otherwise be better to have a constexpr function to generate the result at compile time.

[Mordante]

libcxx/include/experimental/__simd/utility.h

76

This change needs to be done at other functions too.

90

Let's make sure unsupported sizes are ill-formed instead of triggering UB.

[Joy12138]

Rebase.

Due to the large amount of content in this section, I will split them into two patches to submit.

In this patch, we mainly implements the internal storage type of the simd/simd_mask class and the basic part of its auxiliary class reference.

In the next patch we will implement relevant user interfaces, including constructors and subscript access operators, as well as related tests.

The status paper will be updated in the next patch.

[Joy12138]

Fix some comments

[Joy12138]

Fix some CI errors

[Joy12138]

Rebase

[Joy12138]

Fix CI

[philnik]

libcxx/include/experimental/__simd/reference.h

20 ↗

(On Diff #543144)

No need to call it out. If it's _Uglified it's library-internal.

20 ↗

(On Diff #543144)

__reference as a name is really generic.

46 ↗

(On Diff #543144)

It looks like you don't have any tests for the reference type currently. Please add some.

libcxx/include/experimental/__simd/scalar.h

29–30

Why make it so complicated? I'd just go for

// __get
return __data;

// __set
__data = __v;

Also, let's add a few _LIBCPP_ASSERT_UNCATEGORIZED (might need a rebase?) to make sure the index is never out of bounds.

38–39

That makes it a bit more obvious what you do when using it.

libcxx/include/experimental/__simd/utility.h

70

77–78

Isn't this just __v ? std::numeric_limits<_Up>::max() : 0?

libcxx/include/experimental/__simd/vec_ext.h

29–33

Why the conditional? Does this somehow help optimizations?

30

clang-tidy should actually complain here. I'll have to look into this.

41

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

61–66

This isn't portable, and I don't really see the point. Nobody cares what the type is named internally.

[Joy12138]

Rebase and fix some comments

[Joy12138]

libcxx/include/experimental/__simd/vec_ext.h

29–33

libcxx CI - GCC 12 / C++latest gives errors with vector size that is not a power of two:

/home/libcxx-builder/.buildkite-agent/builds/google-libcxx-builder-8484195cd0ed-1/llvm-project/libcxx-ci/build/generic-gcc/include/c++/v1/experimental/__simd/vec_ext.h:30:7: error: number of vector components 3 not a power of two
   30 |   _Tp __data __attribute__((vector_size(sizeof(_Tp) * _Np)));
      |       ^~~~~~

It seems GCC 12 doesn't support non-power-of-two vector lengths. So I added the conditional.

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

61–66

Then the type check of reference in the simd[_mask]_alias.pass.cpp is also unnecessary, right? Can I directly remove them?

[philnik]

libcxx/include/experimental/__simd/vec_ext.h

29–33

I would just always make it a power of two then. If there is no improvement when introducing the conditional, we can just remove it and make both compilers happy.

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

61–66

Yes, they are unnecessary. You should add tests that check the properties of simd::reference and simd_mask::reference though.

[Joy12138]

Rebase and fix CI

[Joy12138]

Fix some comments

[Joy12138]

Fix CI

[Joy12138]

Add test for reference alias

[Joy12138]

Fix CI

[Joy12138]

Fix CI

[Joy12138]

Fix CI

[Joy12138]

Fix CI

[Joy12138]

Fix

[philnik]

LGTM with the remaining comments addressed.

libcxx/include/experimental/__simd/reference.h

33 ↗

(On Diff #543812)

To avoid ADL you don't have to fully qualify the name.

libcxx/include/experimental/__simd/scalar.h

30

Note: Once the data is actually reachable, this should get a test.

libcxx/include/experimental/__simd/utility.h

75

[Joy12138]

Fix comments

[Joy12138]

Rebase

[Joy12138]

Rebase

[Joy12138]

It seems that the long double is a type with a size of 12 bytes on MinGW (DLL, i686). This conflicts with the current implementation. Vector extension requires the input parameter of vector size to be a power of 2 and a multiple of the size of the element type. 12 bytes cannot meet both requirements simultaneously. Should we temporarily exclude long double on MinGW (DLL, i686)? I think it would be more appropriate to add support for it when implement platform specialization optimization. @philnik

[philnik]

In D144364#4636494, @Joy12138 wrote:

It seems that the long double is a type with a size of 12 bytes on MinGW (DLL, i686). This conflicts with the current implementation. Vector extension requires the input parameter of vector size to be a power of 2 and a multiple of the size of the element type. 12 bytes cannot meet both requirements simultaneously. Should we temporarily exclude long double on MinGW (DLL, i686)? I think it would be more appropriate to add support for it when implement platform specialization optimization. @philnik

Sounds fine to me with a TODO.

[Joy12138]

Excluded long double on MinGW (DLL, i686) temperarily

[Joy12138]

Fix CI

[Joy12138]

Rebase

libcxx/include/CMakeLists.txt

set(files
   cwctype
   deque
   errno.h
   exception
   execution
   expected
   experimental/__config
   experimental/__memory
+  experimental/__simd/declaration.h
   experimental/__simd/scalar.h
   experimental/__simd/utility.h
   experimental/__simd/vec_ext.h
   experimental/algorithm
   experimental/deque
   experimental/forward_list
   experimental/functional
   experimental/iterator

libcxx/include/experimental/__simd/declaration.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_DECLARATION_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_DECLARATION_H
+
+#include <experimental/__config>
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
+
+template <class _Tp, class _Abi>
+struct __simd_storage;
+
+template <class _Tp, class _Abi>
+struct __mask_storage;
+
+template <class _Tp, class _Abi>
+struct __simd_traits;
+
+template <class _Tp, class _Abi>
+struct __mask_traits;
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
+
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_DECLARATION_H

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>
+#include <experimental/__simd/declaration.h>
 
 _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
 
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
+
+template <class _Tp>
+struct __simd_storage<_Tp, simd_abi::__scalar> {
+  _Tp __data;
+
+  _Tp __get(size_t __idx) const noexcept { return (&__data)[__idx]; }
+  void __set(size_t __idx, _Tp __v) noexcept { (&__data)[__idx] = __v; }
+};
+
+template <class _Tp>
+struct __mask_storage<_Tp, simd_abi::__scalar> : __simd_storage<bool, simd_abi::__scalar> {};
+
+template <class _Tp>
+struct __simd_traits<_Tp, simd_abi::__scalar> {
+  using _Simd = __simd_storage<_Tp, simd_abi::__scalar>;
+  using _Mask = __mask_storage<_Tp, simd_abi::__scalar>;
+
+  static _Simd __broadcast(_Tp __v) noexcept { return {__v}; }
+
+  template <class _Generator>
+  static _Simd __generate(_Generator&& __g) noexcept {
+    return {__g(std::integral_constant<size_t, 0>())};
+  }
+
+  template <class _Up>
+  static void __load(_Simd& __s, const _Up* __mem) noexcept {
+    __s.__data = static_cast<_Tp>(__mem[0]);
+  }
+};
+
+template <class _Tp>
+struct __mask_traits<_Tp, simd_abi::__scalar> {
+  using _Mask = __mask_storage<_Tp, simd_abi::__scalar>;
+
+  static _Mask __broadcast(bool __v) noexcept { return {__v}; }
+
+  static void __load(_Mask& __s, const bool* __mem) noexcept { __s.__data = __mem[0]; }
+};
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
+
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H

libcxx/include/experimental/__simd/utility.h

 
 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;
 }
 
+template <class _Tp>
+auto __choose_mask_type() {
+  if constexpr (sizeof(_Tp) == 1) {
+    return uint8_t{};
+  } else if constexpr (sizeof(_Tp) == 2) {
+    return uint16_t{};
+  } else if constexpr (sizeof(_Tp) == 4) {
+    return uint32_t{};
+  } else if constexpr (sizeof(_Tp) == 8) {
+    return uint64_t{};
+  }
+#ifndef _LIBCPP_HAS_NO_INT128
+  else if constexpr (sizeof(_Tp) == 16) {
+    return __uint128_t{};
+  }
+#endif
+}
+
+template <class _Tp>
+auto __set_all_bits(bool __v) {
+  using _Up = decltype(__choose_mask_type<_Tp>());
+  _Up __res = 0;
+  for (unsigned long __i = 0; __i < __CHAR_BIT__ * sizeof(_Tp); __i++)
+    __res |= static_cast<_Up>(__v) << __i;
+  return __res;
+}
+
 _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>
+#include <experimental/__simd/declaration.h>
+#include <experimental/__simd/utility.h>
 
 _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
 
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
+
+template <class _Tp, int _Np>
+struct __simd_storage<_Tp, simd_abi::__vec_ext<_Np>> {
+  _Tp __data __attribute__((vector_size(sizeof(_Tp) * _Np)));
+
+  _Tp __get(size_t __idx) const noexcept { return __data[__idx]; }
+  void __set(size_t __idx, _Tp __v) noexcept { __data[__idx] = __v; }
+};
+
+template <class _Tp, int _Np>
+struct __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>
+    : __simd_storage<decltype(__choose_mask_type<_Tp>()), simd_abi::__vec_ext<_Np>> {};
+
+template <class _Tp, int _Np>
+struct __simd_traits<_Tp, simd_abi::__vec_ext<_Np>> {
+  using _Simd = __simd_storage<_Tp, simd_abi::__vec_ext<_Np>>;
+  using _Mask = __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>;
+
+  static _Simd __broadcast(_Tp __v) noexcept {
+    return __generate([=](size_t) { return __v; });
+  }
+
+  template <class _Generator, size_t... _Is>
+  static _Simd __generate_init(_Generator&& __g, std::index_sequence<_Is...>) {
+    return {__g(std::integral_constant<size_t, _Is>())...};
+  }
+
+  template <class _Generator>
+  static _Simd __generate(_Generator&& __g) noexcept {
+    return __generate_init(std::forward<_Generator>(__g), std::make_index_sequence<_Np>());
+  }
+
+  template <class _Up>
+  static void __load(_Simd& __s, const _Up* __mem) noexcept {
+    for (size_t __i = 0; __i < _Np; __i++)
+      __s.__data[__i] = static_cast<_Tp>(__mem[__i]);
+  }
+};
+
+template <class _Tp, int _Np>
+struct __mask_traits<_Tp, simd_abi::__vec_ext<_Np>> {
+  using _Mask = __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>;
+
+  static _Mask __broadcast(bool __v) noexcept {
+    return __generate([=](size_t) { return __set_all_bits<_Tp>(__v); });
+  }
+
+  template <class _Generator, size_t... _Is>
+  static _Mask __generate_init(_Generator&& __g, std::index_sequence<_Is...>) {
+    return _Mask{{__g(std::integral_constant<size_t, _Is>())...}};
+  }
+
+  template <class _Generator>
+  static _Mask __generate(_Generator&& __g) noexcept {
+    return __generate_init(std::forward<_Generator>(__g), std::make_index_sequence<_Np>());
+  }
+
+  static void __load(_Mask& __s, const bool* __mem) noexcept {
+    for (size_t __i = 0; __i < _Np; __i++)
+      __s.__data[__i] = __set_all_bits<_Tp>(__mem[__i]);
+  }
+};
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
+
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H

libcxx/include/experimental/simd

 };
 template<class _Tp, size_t _Np, class... _Abis> using deduce_t =
   typename deduce<_Tp, _Np, _Abis...>::type;
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
 
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
 
-template<class _Vp> class __simd_reference { // exposition only
+template<class _Tp, class _Storage, class _Vp> class __simd_reference { // exposition only
+  template<class, class> friend class simd;
+  template<class, class> friend class simd_mask;
+
+  _Storage& __s_;
+  size_t __idx_;
+
+  __simd_reference(_Storage& __s, size_t __idx) : __s_(__s), __idx_(__idx) {}
+
+  _Vp __get() const { return __s_.__get(__idx_); }
+
+  void __set(_Vp __v) {
+    if constexpr (is_same_v<_Vp, bool>)
+      __s_.__set(__idx_, __set_all_bits<_Tp>(__v));
+    else
+      __s_.__set(__idx_, __v);
+  }
+
 public:
   using value_type = _Vp;
 
   __simd_reference() = delete;
   __simd_reference(const __simd_reference&) = delete;
 
-  operator value_type() const noexcept;
+  operator value_type() const noexcept { return __get(); }
 
-  template<class _Up> __simd_reference operator=(_Up&& __x) && noexcept;
+  template<class _Up>
+  enable_if_t<is_void_v<void_t<decltype(declval<value_type&>() = declval<_Up>())>>, __simd_reference>
+  operator=(_Up&& __v) && noexcept {
+    __set(static_cast<value_type>(std::forward<_Up>(__v)));
+    return {__s_, __idx_};
+  }
 
   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;
public:
   void operator--() && noexcept;
   void operator--(int) && noexcept;
 
   template<class _Up, class _Flags> void copy_from(const _Up* __mem, _Flags) &&;
 };
 
 // 9.6, Class template simd defination
 template<class _Tp, class _Abi> class simd {
+  using _Impl    = __simd_traits<_Tp, _Abi>;
+  using _Storage = typename _Impl::_Simd;
+
+  _Storage __s_;
+
 public:
   using value_type = _Tp;
-  using reference = __simd_reference<value_type>;
+  using reference = __simd_reference<_Tp, _Storage, value_type>;
   using mask_type = simd_mask<_Tp, _Abi>;
   using abi_type = _Abi;
 
   static constexpr size_t size() noexcept { return simd_size_v<value_type, abi_type>; };
 
   simd() noexcept = default;
 
   // 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;
+    simd(_Up&& __value) noexcept : __s_(_Impl::__broadcast(static_cast<value_type>(__value))) {}
+
+  template<class _Up, enable_if_t<is_same_v<abi_type, simd_abi::fixed_size<size()>> &&
+                                  __is_non_narrowing_arithmetic_convertible<_Up, value_type>(), int> = 0>
+    simd(const simd<_Up, simd_abi::fixed_size<size()>>& __value) noexcept {
+      for (size_t __i = 0; __i < size(); __i++)
+        (*this)[__i] = static_cast<_Tp>(__value[__i]);
+    }
+
   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);
+    explicit simd(_Gen&& __gen) noexcept : __s_(_Impl::__generate(std::forward<_Gen>(__gen))) {}
+
+  template<class _Up, class _Flags, enable_if_t<__is_vectorizable<_Up>() && is_simd_flag_type_v<_Flags>, int> = 0>
+    simd(const _Up* __mem, _Flags) {
+      _Impl::__load(__s_, _Flags::template __apply<simd>(__mem));
+    }
 
   // 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);
 
   // 9.6.6, simd subscript operators
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
+  reference operator[](size_t __i) { return reference(__s_, __i); }
+  value_type operator[](size_t __i) const { return __s_.__get(__i); }
 
   // 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;
public:
   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;
 };
 
 // 9.8, Class template simd_mask defination
 template<class _Tp, class _Abi> class simd_mask {
+  using _Impl    = __mask_traits<_Tp, _Abi>;
+  using _Storage = typename _Impl::_Mask;
+
+  _Storage __s_;
+
 public:
   using value_type = bool;
-  using reference = __simd_reference<value_type>;
+  using reference = __simd_reference<_Tp, _Storage, value_type>;
   using simd_type = simd<_Tp, _Abi>;
   using abi_type = _Abi;
 
   static constexpr size_t size() noexcept { return simd_type::size(); };
 
   simd_mask() noexcept = default;
 
   // 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);
+  explicit simd_mask(value_type __value) noexcept : __s_(_Impl::__broadcast(__value)) {}
+
+  template<class _Up, enable_if_t<!is_void_v<_Up> && is_same_v<abi_type, simd_abi::fixed_size<size()>>, int> = 0>
+    simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>&  __value) noexcept {
+      for (size_t __i = 0; __i < size(); __i++)
+        (*this)[__i] = __value[__i];
+    }
+
+  template<class _Flags, enable_if_t<is_simd_flag_type_v<_Flags>, int> = 0>
+    simd_mask(const value_type* __mem, _Flags) {
+      _Impl::__load(__s_, _Flags::template __apply<simd_mask>(__mem));
+    }
 
   // 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);
 
   // 9.8.5, Subscript operators
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
+  reference operator[](size_t __i) { return reference(__s_, __i); }
+  value_type operator[](size_t __i) const { return __s_.__get(__i); }
 
   // 9.8.6, Unary operators
   simd_mask operator!() const noexcept;
 
   // 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;

libcxx/test/std/experimental/simd/simd.class/simd_ctor.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) noexcept;
+// template<class U> simd(const simd<U, simd_abi::fixed_size<size()>>&) noexcept;
+// template<class G> explicit simd(G&& gen) noexcept;
+// template<class U, class Flags> simd(const U* mem, Flags f);
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+template <typename T>
+class implicit_type {
+  T val;
+
+public:
+  implicit_type(T val) : val(val) {}
+  operator T() const { return val; }
+};
+
+#define GENARETE_FOR_BROADCAST_SIMD_CTOR(_Up, suffix)                                                                  \
+  if constexpr (ex::__is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) {                                           \
+    ex::simd<_Tp, SimdAbi> broadcast_from_type_##suffix(static_cast<_Up>(3));                                          \
+    assert_simd_value_correct(broadcast_from_type_##suffix, origin_value);                                             \
+  }
+
+struct CheckBroadCastSimdCtor {
+  template <class _Tp, class SimdAbi, std::size_t>
+  void operator()() {
+    constexpr size_t array_size = ex::simd_size_v<_Tp, SimdAbi>;
+    std::array<_Tp, array_size> origin_value;
+    for (size_t i = 0; i < array_size; ++i)
+      origin_value[i] = static_cast<_Tp>(3);
+
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(char16_t, char16)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(char32_t, char32)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(unsigned char, uchar)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(signed char, schar)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(wchar_t, wchar)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(unsigned short, ushort)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(short, short)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(unsigned int, uint)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(int, int)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(unsigned long, ulong)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(long, long)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(unsigned long long, ulonglong)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(long long, longlong)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(float, float)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(double, double)
+    GENARETE_FOR_BROADCAST_SIMD_CTOR(long double, longdouble)
+
+    implicit_type<_Tp> implicit_value_3(3);
+    ex::simd<_Tp, SimdAbi> expected_simd_from_implicit_convert(implicit_value_3);
+    assert_simd_value_correct(expected_simd_from_implicit_convert, origin_value);
+
+    int int_value_3 = 3;
+    ex::simd<_Tp, SimdAbi> expected_simd_from_int(int_value_3);
+    assert_simd_value_correct(expected_simd_from_int, origin_value);
+
+    if constexpr (std::is_unsigned_v<_Tp>) {
+      unsigned int uint_value_3 = static_cast<unsigned int>(3);
+      ex::simd<_Tp, SimdAbi> expected_simd_from_uint(uint_value_3);
+      assert_simd_value_correct(expected_simd_from_uint, origin_value);
+    }
+  }
+};
+
+#define GENARETE_FOR_FIXED_SIMD_CTOR(_Up, suffix)                                                                      \
+  if constexpr (ex::__is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) {                                           \
+    ex::simd<_Up, SimdAbi> suffix##_simd([](_Up i) { return i; });                                                     \
+    ex::simd<_Tp, SimdAbi> fixed_from_type_##suffix(suffix##_simd);                                                    \
+    std::array<_Tp, _Np> expected_value_in_##suffix;                                                                   \
+    for (size_t i = 0; i < _Np; i++)                                                                                   \
+      expected_value_in_##suffix[i] = static_cast<_Tp>(suffix##_simd[i]);                                              \
+    assert_simd_value_correct(fixed_from_type_##suffix, expected_value_in_##suffix);                                   \
+  }
+
+struct CheckFixedSimdCtor {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    if constexpr (std::is_same_v<SimdAbi, ex::simd_abi::fixed_size<_Np>>) {
+      GENARETE_FOR_FIXED_SIMD_CTOR(char16_t, char16)
+      GENARETE_FOR_FIXED_SIMD_CTOR(char32_t, char32)
+      GENARETE_FOR_FIXED_SIMD_CTOR(unsigned char, uchar)
+      GENARETE_FOR_FIXED_SIMD_CTOR(signed char, schar)
+      GENARETE_FOR_FIXED_SIMD_CTOR(wchar_t, wchar)
+      GENARETE_FOR_FIXED_SIMD_CTOR(unsigned short, ushort)
+      GENARETE_FOR_FIXED_SIMD_CTOR(short, short)
+      GENARETE_FOR_FIXED_SIMD_CTOR(unsigned int, uint)
+      GENARETE_FOR_FIXED_SIMD_CTOR(int, int)
+      GENARETE_FOR_FIXED_SIMD_CTOR(unsigned long, ulong)
+      GENARETE_FOR_FIXED_SIMD_CTOR(long, long)
+      GENARETE_FOR_FIXED_SIMD_CTOR(unsigned long long, ulonglong)
+      GENARETE_FOR_FIXED_SIMD_CTOR(long long, longlong)
+      GENARETE_FOR_FIXED_SIMD_CTOR(float, float)
+      GENARETE_FOR_FIXED_SIMD_CTOR(double, double)
+      GENARETE_FOR_FIXED_SIMD_CTOR(long double, longdouble)
+    }
+  }
+};
+
+struct CheckGenerateSimdCtor {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> origin_simd([](_Tp i) { return i; });
+    constexpr size_t array_size = origin_simd.size();
+    std::array<_Tp, array_size> expected_value;
+    for (size_t i = 0; i < array_size; ++i)
+      expected_value[i] = static_cast<_Tp>(i);
+    assert_simd_value_correct(origin_simd, expected_value);
+  }
+};
+
+struct CheckLoadSimdCtor {
+  template <class _Tp, class SimdAbi, std::size_t>
+  void operator()() {
+    {
+      constexpr auto alignas_size = ex::memory_alignment_v<ex::simd<_Tp, SimdAbi>, _Tp>;
+      constexpr auto array_size   = ex::simd_size_v<_Tp, SimdAbi>;
+      alignas(alignas_size) _Tp buffer[array_size];
+      std::array<_Tp, array_size> expected_value;
+      for (size_t i = 0; i < array_size; i++) {
+        buffer[i]         = static_cast<_Tp>(i + 1);
+        expected_value[i] = buffer[i];
+      }
+      ex::simd<_Tp, SimdAbi> origin_simd(buffer, ex::vector_aligned_tag());
+      assert_simd_value_correct(origin_simd, expected_value);
+    }
+    {
+      constexpr auto alignas_size = 32;
+      constexpr auto array_size   = ex::simd_size_v<_Tp, SimdAbi>;
+      alignas(alignas_size) _Tp buffer[array_size];
+      std::array<_Tp, array_size> expected_value;
+      for (size_t i = 0; i < array_size; i++) {
+        buffer[i]         = static_cast<_Tp>(i + 1);
+        expected_value[i] = buffer[i];
+      }
+      ex::simd<_Tp, SimdAbi> origin_simd(buffer, ex::overaligned_tag<alignas_size>());
+      assert_simd_value_correct(origin_simd, expected_value);
+    }
+    {
+      constexpr auto alignas_size = std::bit_ceil(alignof(_Tp));
+      constexpr auto array_size   = ex::simd_size_v<_Tp, SimdAbi>;
+      alignas(alignas_size) _Tp buffer[array_size];
+      std::array<_Tp, array_size> expected_value;
+      for (size_t i = 0; i < array_size; i++) {
+        buffer[i]         = static_cast<_Tp>(i + 1);
+        expected_value[i] = buffer[i];
+      }
+      ex::simd<_Tp, SimdAbi> origin_simd(buffer, ex::element_aligned_tag());
+      assert_simd_value_correct(origin_simd, expected_value);
+    }
+  }
+};
+
+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, _Np>();
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckBroadCastSimdCtor>();
+  test_all_simd_abi<CheckFixedSimdCtor>();
+  test_all_simd_abi<CheckGenerateSimdCtor>();
+  test_all_simd_abi<CheckLoadSimdCtor>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.class/simd_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;
+// simd(const simd&)                = default;
+// simd& operator=(const simd&)     = default;
+// simd(simd&&) noexcept            = default;
+// simd& operator=(simd&&) noexcept = default;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+// See https://www.open-std.org/jtc1/sc22/WG21/docs/papers/2019/n4808.pdf
+// Default intialization performs no initialization of the elements; value-initialization initializes each element with T().
+// [ Note: Thus, default initialization leaves the elements in an indeterminate state. — end note ]
+struct CheckSimdDefaultCtor {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> pure_simd;
+    // trash value in default ctor
+    static_assert(pure_simd.size() > 0);
+  }
+};
+struct CheckSimdCopyCtor {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> pure_simd([](_Tp i) { return i; });
+    ex::simd<_Tp, SimdAbi> from_copy_ctor(pure_simd);
+    std::array<_Tp, pure_simd.size()> expected_value;
+    for (size_t i = 0; i < pure_simd.size(); ++i)
+      expected_value[i] = pure_simd[i];
+    assert_simd_value_correct(from_copy_ctor, expected_value);
+  }
+};
+struct CheckSimdMoveCtor {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> pure_simd([](_Tp i) { return i; });
+    ex::simd<_Tp, SimdAbi> from_move_ctor(std::move(pure_simd));
+    std::array<_Tp, pure_simd.size()> expected_value;
+    for (size_t i = 0; i < pure_simd.size(); ++i)
+      expected_value[i] = pure_simd[i];
+    assert_simd_value_correct(from_move_ctor, expected_value);
+  }
+};
+struct CheckSimdCopyAssignment {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> pure_simd([](_Tp i) { return i; });
+    ex::simd<_Tp, SimdAbi> from_copy_assignment;
+    from_copy_assignment = pure_simd;
+    std::array<_Tp, pure_simd.size()> expected_value;
+    for (size_t i = 0; i < pure_simd.size(); ++i)
+      expected_value[i] = pure_simd[i];
+    assert_simd_value_correct(from_copy_assignment, expected_value);
+  }
+};
+struct CheckSimdMoveAssignment {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> pure_simd([](_Tp i) { return i; });
+    ex::simd<_Tp, SimdAbi> from_move_assignment;
+    from_move_assignment = std::move(pure_simd);
+    std::array<_Tp, pure_simd.size()> expected_value;
+    for (size_t i = 0; i < pure_simd.size(); ++i)
+      expected_value[i] = pure_simd[i];
+    assert_simd_value_correct(from_move_assignment, expected_value);
+  }
+};
+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<CheckSimdDefaultCtor>();
+  test_all_simd_abi<CheckSimdCopyCtor>();
+  test_all_simd_abi<CheckSimdMoveCtor>();
+  test_all_simd_abi<CheckSimdCopyAssignment>();
+  test_all_simd_abi<CheckSimdMoveAssignment>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.class/simd_subscr.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]
+// reference operator[](size_t i);
+// value_type operator[](size_t i) const;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckSimdReferenceSubscr {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> origin_simd([](_Tp i) { return i; });
+    for (size_t i = 0; i < origin_simd.size(); ++i) {
+      static_assert(is_simd_reference<decltype(origin_simd[i])>::value);
+      assert(origin_simd[i] == static_cast<_Tp>(i));
+    }
+  }
+};
+struct CheckSimdValueTypeSubscr {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    const ex::simd<_Tp, SimdAbi> origin_simd([](_Tp i) { return i; });
+    for (size_t i = 0; i < origin_simd.size(); ++i) {
+      static_assert(std::is_pod_v<decltype(origin_simd[i])>);
+      static_assert(std::is_same_v<_Tp, decltype(origin_simd[i])>);
+      assert(origin_simd[i] == static_cast<_Tp>(i));
+    }
+  }
+};
+
+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<CheckSimdReferenceSubscr>();
+  test_all_simd_abi<CheckSimdValueTypeSubscr>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.mask.class/simd_mask_ctor.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]
+// explicit simd_mask(value_type) noexcept;
+// template<class U> simd_mask(const simd_mask<U, simd_abi::fixed_size<size()>>&) noexcept;
+// template<class Flags> simd_mask(const value_type* mem, Flags);
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckBroadCastSimdMaskCtor {
+  template <class _Tp, class SimdAbi, std::size_t>
+  void operator()() {
+    constexpr size_t array_size = ex::simd_size_v<_Tp, SimdAbi>;
+    const ex::simd_mask<_Tp, SimdAbi> mask_ctor_from_broadcast(false);
+    const std::array<bool, array_size> expected_value{};
+    assert_simd_mask_value_correct(mask_ctor_from_broadcast, expected_value);
+  }
+};
+
+#define GENERATE_FOR_FIXED_SIMD_MASK_CTOR(_Up, suffix)                                                                 \
+  ex::simd_mask<_Up, SimdAbi> suffix##_mask;                                                                           \
+  std::array<bool, _Np> expected_value_in_##suffix;                                                                    \
+  for (size_t i = 0; i < _Np; i++) {                                                                                   \
+    suffix##_mask[i]              = static_cast<bool>(i % 2);                                                          \
+    expected_value_in_##suffix[i] = suffix##_mask[i];                                                                  \
+  }                                                                                                                    \
+  ex::simd_mask<_Tp, SimdAbi> fixed_mask_from_type_##suffix(suffix##_mask);                                            \
+  assert_simd_mask_value_correct(fixed_mask_from_type_##suffix, expected_value_in_##suffix);
+
+struct CheckFixedSimdMaskCtor {
+  template <class _Tp, class SimdAbi, std::size_t _Np>
+  void operator()() {
+    if constexpr (std::is_same_v<SimdAbi, ex::simd_abi::fixed_size<_Np>>) {
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(char16_t, char16)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(char32_t, char32)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(unsigned char, uchar)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(signed char, schar)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(wchar_t, wchar)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(unsigned short, ushort)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(short, short)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(unsigned int, uint)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(int, int)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(unsigned long, ulong)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(long, long)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(unsigned long long, ulonglong)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(long long, longlong)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(float, float)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(double, double)
+      GENERATE_FOR_FIXED_SIMD_MASK_CTOR(long double, longdouble)
+    }
+  }
+};
+
+struct CheckLoadSimdMaskCtor {
+  template <class _Tp, class SimdAbi, std::size_t>
+  void operator()() {
+    constexpr size_t array_size = ex::simd_size_v<_Tp, SimdAbi>;
+    {
+      alignas(ex::memory_alignment_v<ex::simd_mask<_Tp, SimdAbi>>) bool buffer[array_size];
+      std::array<bool, array_size> expected_value;
+      for (size_t i = 0; i < array_size; i++) {
+        buffer[i]         = static_cast<bool>(i % 2);
+        expected_value[i] = buffer[i];
+      }
+      ex::simd_mask<_Tp, SimdAbi> simd_mask(buffer, ex::vector_aligned_tag());
+      assert_simd_mask_value_correct(simd_mask, expected_value);
+    }
+    {
+      alignas(8) bool buffer[array_size];
+      std::array<bool, array_size> expected_value;
+      for (size_t i = 0; i < array_size; i++) {
+        buffer[i]         = static_cast<bool>(i % 2);
+        expected_value[i] = buffer[i];
+      }
+      ex::simd_mask<_Tp, SimdAbi> simd_mask(buffer, ex::overaligned_tag<8>());
+      assert_simd_mask_value_correct(simd_mask, expected_value);
+    }
+    {
+      alignas(alignof(bool)) bool buffer[array_size];
+      std::array<bool, array_size> expected_value;
+      for (size_t i = 0; i < array_size; i++) {
+        buffer[i]         = static_cast<bool>(i % 2);
+        expected_value[i] = buffer[i];
+      }
+      ex::simd_mask<_Tp, SimdAbi> simd_mask(buffer, ex::element_aligned_tag());
+      assert_simd_mask_value_correct(simd_mask, expected_value);
+    }
+  }
+};
+
+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, _Np>();
+  test_simd_abi<F, _Np, _Tp, SimdAbis...>();
+}
+
+int main(int, char**) {
+  test_all_simd_abi<CheckBroadCastSimdMaskCtor>();
+  test_all_simd_abi<CheckFixedSimdMaskCtor>();
+  test_all_simd_abi<CheckLoadSimdMaskCtor>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.mask.class/simd_mask_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.mask.class]
+// simd_mask()                                = default;
+// simd_mask(const simd_mask&)                = default;
+// simd_mask& operator=(const simd_mask&)     = default;
+// simd_mask(simd_mask&&) noexcept            = default;
+// simd_mask& operator=(simd_mask&&) noexcept = default;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+// See https://www.open-std.org/jtc1/sc22/WG21/docs/papers/2019/n4808.pdf
+// Default intialization performs no initialization of the elements; value-initialization initializes each element with T().
+// [ Note: Thus, default initialization leaves the elements in an indeterminate state. — end note ]
+struct CheckSimdMaskDefaultCtor {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd_mask<_Tp, SimdAbi> pure_mask;
+    // trash value in default ctor
+    static_assert(pure_mask.size() > 0);
+  }
+};
+struct CheckSimdMaskCopyCtor {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd_mask<_Tp, SimdAbi> pure_mask;
+    std::array<bool, pure_mask.size()> expected_value;
+    for (size_t i = 0; i < pure_mask.size(); i++) {
+      pure_mask[i]      = static_cast<bool>(i % 2);
+      expected_value[i] = pure_mask[i];
+    }
+    ex::simd_mask<_Tp, SimdAbi> from_copy_ctor(pure_mask);
+    assert_simd_mask_value_correct(from_copy_ctor, expected_value);
+  }
+};
+struct CheckSimdMaskMoveCtor {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd_mask<_Tp, SimdAbi> pure_mask;
+    std::array<bool, pure_mask.size()> expected_value;
+    for (size_t i = 0; i < pure_mask.size(); i++) {
+      pure_mask[i]      = static_cast<bool>(i % 2);
+      expected_value[i] = pure_mask[i];
+    }
+    ex::simd_mask<_Tp, SimdAbi> from_move_ctor(std::move(pure_mask));
+    assert_simd_mask_value_correct(from_move_ctor, expected_value);
+  }
+};
+struct CheckSimdMaskCopyAssignment {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd_mask<_Tp, SimdAbi> pure_mask;
+    std::array<bool, pure_mask.size()> expected_value;
+    for (size_t i = 0; i < pure_mask.size(); i++) {
+      pure_mask[i]      = static_cast<bool>(i % 2);
+      expected_value[i] = pure_mask[i];
+    }
+    ex::simd_mask<_Tp, SimdAbi> from_copy_assignment;
+    from_copy_assignment = pure_mask;
+    assert_simd_mask_value_correct(from_copy_assignment, expected_value);
+  }
+};
+struct CheckSimdMaskMoveAssignment {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd_mask<_Tp, SimdAbi> pure_mask;
+    std::array<bool, pure_mask.size()> expected_value;
+    for (size_t i = 0; i < pure_mask.size(); i++) {
+      pure_mask[i]      = static_cast<bool>(i % 2);
+      expected_value[i] = pure_mask[i];
+    }
+    ex::simd_mask<_Tp, SimdAbi> from_move_assignment;
+    from_move_assignment = std::move(pure_mask);
+    assert_simd_mask_value_correct(from_move_assignment, expected_value);
+  }
+};
+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<CheckSimdMaskDefaultCtor>();
+  test_all_simd_abi<CheckSimdMaskCopyCtor>();
+  test_all_simd_abi<CheckSimdMaskMoveCtor>();
+  test_all_simd_abi<CheckSimdMaskCopyAssignment>();
+  test_all_simd_abi<CheckSimdMaskMoveAssignment>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.mask.class/simd_mask_subscr.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]
+// reference operator[](size_t i);
+// value_type operator[](size_t i) const;
+
+#include "../test_utils.h"
+#include <cassert>
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+struct CheckSimdMaskReferenceSubscr {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd_mask<_Tp, SimdAbi> origin_simd_mask(true);
+    for (size_t i = 0; i < origin_simd_mask.size(); ++i) {
+      static_assert(is_simd_reference<decltype(origin_simd_mask[i])>::value);
+      assert(origin_simd_mask[i] == true);
+    }
+  }
+};
+struct CheckSimdMaskValueTypeSubscr {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    const ex::simd_mask<_Tp, SimdAbi> origin_simd_mask(true);
+    for (size_t i = 0; i < origin_simd_mask.size(); ++i) {
+      static_assert(std::is_pod_v<decltype(origin_simd_mask[i])>);
+      static_assert(std::is_same_v<bool, decltype(origin_simd_mask[i])>);
+      assert(origin_simd_mask[i] == true);
+    }
+  }
+};
+
+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<CheckSimdMaskReferenceSubscr>();
+  test_all_simd_abi<CheckSimdMaskValueTypeSubscr>();
+  return 0;
+}

libcxx/test/std/experimental/simd/simd.reference/reference_value_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.reference]
+// operator value_type() const noexcept;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+struct CheckSimdReferenceValueType {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd<_Tp, SimdAbi> origin_simd([](_Tp i) { return i; });
+    for (size_t i = 0; i < origin_simd.size(); i++) {
+      static_assert(std::is_same_v<decltype(_Tp(origin_simd[i])), _Tp>);
+      assert(_Tp(origin_simd[i]) == static_cast<_Tp>(i));
+    }
+  }
+};
+struct CheckMaskReferenceValueType {
+  template <class _Tp, class SimdAbi>
+  void operator()() {
+    ex::simd_mask<_Tp, SimdAbi> origin_mask(true);
+    for (size_t i = 0; i < origin_mask.size(); i++) {
+      static_assert(std::is_same_v<decltype(bool(origin_mask[i])), bool>);
+      assert(bool(origin_mask[i]) == true);
+    }
+  }
+};
+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<CheckSimdReferenceValueType>();
+  test_all_simd_abi<CheckMaskReferenceValueType>();
+  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 T>
+struct is_simd_reference : std::false_type {};
+
+template <class _Tp, class _Storage, class _ValueType>
+struct is_simd_reference<ex::__simd_reference<_Tp, _Storage, _ValueType>> : std::true_type {};
+
 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,
void test_all_simd_abi() {
   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);
 }
+
+template <std::size_t ArraySize, class SimdAbi, class _Tp>
+void assert_simd_value_correct(const ex::simd<_Tp, SimdAbi>& origin_simd,
+                               const std::array<_Tp, ArraySize>& expected_value) {
+  for (size_t i = 0; i < origin_simd.size(); ++i)
+    assert(origin_simd[i] == expected_value[i]);
+}
+
+template <std::size_t ArraySize, class SimdAbi, class _Tp>
+void assert_simd_mask_value_correct(const ex::simd_mask<_Tp, SimdAbi>& origin_mask,
+                                    const std::array<bool, ArraySize>& expected_value) {
+  for (size_t i = 0; i < origin_mask.size(); ++i)
+    assert(origin_mask[i] == expected_value[i]);
+}
+
 #endif // TEST_UTIL_H