[libcxx] implement <experimental/simd> simd_mask<> and operators.

[timshen]

Summary

simd_mask<T, Abi> stores a simd<U, Abi>, where U has the same length of T, but is an unsigned integer. Then all functionality of simd_mask<T, Abi> can be implemented in terms of simd<U, Abi>.

For reference, Vc seems to store an int as a bitset. This results into inefficient code:

• https://godbolt.org/g/e4uDPM storing int is slow.
• https://godbolt.org/g/hT7SYT storing simd<U, Abi> has zero cost.

[timshen]

Remove unintended binary file.

[timshen]

Rebased.

[timshen]

Rebase.

libcxx/include/experimental/simd

public:
   _Tp __get(size_t __index) const { return __storage_[__index]; };
   void __set(size_t __index, _Tp __val) { __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, "");
+  static_assert(std::is_same<_Vp, _Tp>::value ||
+                    (std::is_same<_Vp, bool>::value &&
+                     std::is_unsigned<_Tp>::value),
+                "");
 
   template <class, class>
   friend struct simd;
 
   template <class, class>
   friend struct simd_mask;
 
+  template <class, class>
+  friend class simd_mask;
+
   __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;
 
+  static _Vp __to_value_type(_Tp __val) { return __val; }
+
+  static _Tp __from_value_type(_Vp __val) {
+    if (std::is_same<_Vp, bool>::value) {
+      return __val ? -1 : 0;
+    }
+    return __val;
+  }
+
 public:
   __simd_reference() = delete;
   __simd_reference& operator=(const __simd_reference&) = delete;
 
-  operator _Vp() const { return __ptr_->__get(__index_); }
+  operator _Vp() const { return __to_value_type(__ptr_->__get(__index_)); }
 
-  __simd_reference operator=(_Vp __value) && {
-    __ptr_->__set(__index_, __value);
+  __simd_reference operator=(_Vp __val) && {
+    __ptr_->__set(__index_, __from_value_type(__val));
     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;
+    return __to_value_type(__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;
+    return __to_value_type(__val);
   }
 
-  __simd_reference operator+=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) + __value;
+  __simd_reference operator+=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) + __from_value_type(__val);
   }
 
-  __simd_reference operator-=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) - __value;
+  __simd_reference operator-=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) - __from_value_type(__val);
   }
 
-  __simd_reference operator*=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) * __value;
+  __simd_reference operator*=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) * __from_value_type(__val);
   }
 
-  __simd_reference operator/=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) / __value;
+  __simd_reference operator/=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) / __from_value_type(__val);
   }
 
-  __simd_reference operator%=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) % __value;
+  __simd_reference operator%=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) % __from_value_type(__val);
   }
 
-  __simd_reference operator>>=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) >> __value;
+  __simd_reference operator>>=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) >> __from_value_type(__val);
   }
 
-  __simd_reference operator<<=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) << __value;
+  __simd_reference operator<<=(_Vp __val) && {
+    return std::move(*this) = __ptr_->__get(__index_)
+                              << __from_value_type(__val);
   }
 
-  __simd_reference operator&=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) & __value;
+  __simd_reference operator&=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) & __from_value_type(__val);
   }
 
-  __simd_reference operator|=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) | __value;
+  __simd_reference operator|=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) | __from_value_type(__val);
   }
 
-  __simd_reference operator^=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) ^ __value;
+  __simd_reference operator^=(_Vp __val) && {
+    return std::move(*this) =
+               __ptr_->__get(__index_) ^ __from_value_type(__val);
   }
 };
 
 template <class _To, class _From>
 constexpr auto __is_non_narrowing_convertible_impl(_From a [[gnu::unused]])
     -> decltype(_To{a}, true) {
   return true;
 }

 };
 
 template <class _Tp>
 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;
 }
 
+template <size_t __num_bytes>
+struct __unsigned_traits {};
+
+template <>
+struct __unsigned_traits<1> {
+  using type = uint8_t;
+};
+
+template <>
+struct __unsigned_traits<2> {
+  using type = uint16_t;
+};
+
+template <>
+struct __unsigned_traits<4> {
+  using type = uint32_t;
+};
+
+template <>
+struct __unsigned_traits<8> {
+  using type = uint64_t;
+};
+
+#if !defined(_LIBCPP_HAS_NO_INT128)
+template <>
+struct __unsigned_traits<16> {
+  using type = __uint128_t;
+};
+#endif // !defined(_LIBCPP_HAS_NO_INT128)
+
 _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>;
 

 concat(const simd_mask<_Tp, _Abis>&...);
 
 template <class _Tp, class _Abi, size_t _Np>
 simd_mask<_Tp, rebind_abi_t<_Tp, _Np, _Abi>>
 concat(const std::array<simd_mask<_Tp, _Abi>, _Np>&);
 
 // reductions [simd.mask.reductions]
 template <class _Tp, class _Abi>
-bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
+bool all_of(const simd_mask<_Tp, _Abi>& __m) noexcept {
+  bool __ret = true;
+  for (size_t __i = 0; __i < __m.size(); __i++) {
+    __ret &= __m[__i];
+  }
+  return __ret;
+}
 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;
public:
   simd() = default;
   simd(const simd&) = default;
   simd& operator=(const simd&) = default;
 
   static constexpr size_t size() noexcept {
     return simd_size<_Tp, _Abi>::value;
   }
 
+  template <class, class>
+  friend class simd_mask;
+
 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 &&
friend simd& operator<<=(simd& __a, int __offset) {
     return __a = __a << __offset;
   }
 
   friend simd& operator>>=(simd& __a, int __offset) {
     return __a = __a >> __offset;
   }
 
   // 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&);
+  friend mask_type operator==(const simd& __a, const simd& __b) {
+    mask_type __mask;
+    for (size_t __i = 0; __i < __a.size(); __i++) {
+      __mask[__i] = __a[__i] == __b[__i];
+    }
+    return __mask;
+  }
+
+  friend mask_type operator!=(const simd& __a, const simd& __b) {
+    mask_type __mask;
+    for (size_t __i = 0; __i < __a.size(); __i++) {
+      __mask[__i] = __a[__i] != __b[__i];
+    }
+    return __mask;
+  }
+
+  friend mask_type operator>=(const simd& __a, const simd& __b) {
+    mask_type __mask;
+    for (size_t __i = 0; __i < __a.size(); __i++) {
+      __mask[__i] = __a[__i] >= __b[__i];
+    }
+    return __mask;
+  }
+
+  friend mask_type operator<=(const simd& __a, const simd& __b) {
+    mask_type __mask;
+    for (size_t __i = 0; __i < __a.size(); __i++) {
+      __mask[__i] = __a[__i] <= __b[__i];
+    }
+    return __mask;
+  }
+
+  friend mask_type operator>(const simd& __a, const simd& __b) {
+    mask_type __mask;
+    for (size_t __i = 0; __i < __a.size(); __i++) {
+      __mask[__i] = __a[__i] > __b[__i];
+    }
+    return __mask;
+  }
+
+  friend mask_type operator<(const simd& __a, const simd& __b) {
+    mask_type __mask;
+    for (size_t __i = 0; __i < __a.size(); __i++) {
+      __mask[__i] = __a[__i] < __b[__i];
+    }
+    return __mask;
+  }
 
 #if !defined(_LIBCPP_HAS_NO_VECTOR_EXTENSION) && defined(_LIBCPP_COMPILER_CLANG)
   template <size_t... __indices, class _Up, int __num_element>
   friend simd<_Up, __simd_abi<_StorageKind::_VecExt, sizeof...(__indices)>>
   __simd_shuffle(
       const simd<_Up, __simd_abi<_StorageKind::_VecExt, __num_element>>& __v,
       const simd<_Up, __simd_abi<_StorageKind::_VecExt, __num_element>>& __u,
       std::index_sequence<__indices...>);
 #endif
 };
 
 // [simd.mask.class]
 template <class _Tp, class _Abi>
-// TODO: implement simd_mask
 class simd_mask {
+  using __element_type = typename __unsigned_traits<sizeof(_Tp)>::type;
+
+  simd<__element_type, _Abi> __s_;
+
+  explicit simd_mask(const simd<__element_type, _Abi>& __mask) : __s_(__mask) {}
+
 public:
   using value_type = bool;
-  // TODO: this is strawman implementation. Turn it into a proxy type.
-  using reference = bool&;
+  using reference = __simd_reference<bool, __element_type, _Abi>;
   using simd_type = simd<_Tp, _Abi>;
   using abi_type = _Abi;
-  static constexpr size_t size() noexcept;
+
+  static constexpr size_t size() noexcept {
+    return simd<__element_type, _Abi>::size();
+  }
+
   simd_mask() = default;
 
   // broadcast constructor
-  explicit simd_mask(value_type) noexcept;
+  explicit simd_mask(value_type __value) noexcept {
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = __value;
+    }
+  }
 
   // implicit type conversion constructor
-  template <class _Up>
-  simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>&) noexcept;
+  template <
+      class _Up,
+      class = typename std::enable_if<
+          !std::is_void<_Up>::value &&
+          std::is_same<abi_type, simd_abi::fixed_size<size()>>::value>::type>
+  simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>& __v) noexcept {
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = __v[__i];
+    }
+  }
 
   // load constructor
-  template <class _Flags>
-  simd_mask(const value_type*, _Flags);
+  template <class _Flags, class = typename std::enable_if<
+                              is_simd_flag_type<_Flags>::value>::type>
+  simd_mask(const value_type* __buffer, _Flags) {
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = __buffer[__i];
+    }
+  }
 
   // loads [simd.mask.copy]
   template <class _Flags>
-  void copy_from(const value_type*, _Flags);
+  typename std::enable_if<is_simd_flag_type<_Flags>::value>::type
+  copy_from(const value_type* __buffer, _Flags) {
+    *this = simd_mask(__buffer, _Flags());
+  }
+
   template <class _Flags>
-  void copy_to(value_type*, _Flags) const;
+  typename std::enable_if<is_simd_flag_type<_Flags>::value>::type
+  copy_to(value_type* __buffer, _Flags) const {
+    for (size_t __i = 0; __i < size(); __i++) {
+      __buffer[__i] = (*this)[__i];
+    }
+  }
 
   // scalar access [simd.mask.subscr]
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
+  reference operator[](size_t __i) { return reference(&__s_.__s_, __i); }
+
+  value_type operator[](size_t __i) const { return __s_[__i]; }
 
   // unary operators [simd.mask.unary]
-  simd_mask operator!() const noexcept;
+  simd_mask operator!() const noexcept { return simd_mask(~__s_); }
 
   // 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;
+  friend simd_mask operator&&(const simd_mask& __a,
+                              const simd_mask& __b) noexcept {
+    return __a & __b;
+  }
+
+  friend simd_mask operator||(const simd_mask& __a,
+                              const simd_mask& __b) noexcept {
+    return __a | __b;
+  }
+
+  friend simd_mask operator&(const simd_mask& __a,
+                             const simd_mask& __b) noexcept {
+    return simd_mask(__a.__s_ & __b.__s_);
+  }
+
+  friend simd_mask operator|(const simd_mask& __a,
+                             const simd_mask& __b) noexcept {
+    return simd_mask(__a.__s_ | __b.__s_);
+  }
+
+  friend simd_mask operator^(const simd_mask& __a,
+                             const simd_mask& __b) noexcept {
+    return simd_mask(__a.__s_ ^ __b.__s_);
+  }
 
   // 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;
+  friend simd_mask& operator&=(simd_mask& __a, const simd_mask& __b) noexcept {
+    return __a = __a & __b;
+  }
+
+  friend simd_mask& operator|=(simd_mask& __a, const simd_mask& __b) noexcept {
+    return __a = __a | __b;
+  }
+
+  friend simd_mask& operator^=(simd_mask& __a, const simd_mask& __b) noexcept {
+    return __a = __a ^ __b;
+  }
 
   // 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;
+  friend simd_mask operator==(const simd_mask& __a,
+                              const simd_mask& __b) noexcept {
+    return !(__a ^ __b);
+  }
+
+  friend simd_mask operator!=(const simd_mask& __a,
+                              const simd_mask& __b) noexcept {
+    return __a ^ __b;
+  }
 };
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */

libcxx/test/std/experimental/simd/simd.elementwise/operators.pass.cpp

 //
 // 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&);
 
 #include <cassert>
 #include <cstdint>
 #include <experimental/simd>
 
 using namespace std::experimental::parallelism_v2;
 
 template <typename T, typename Abi>
void test_mutating_opreators() {
   }
   {
     native_simd<int> a(42);
     assert(equal(a >>= 4, native_simd<int>(42 >> 4)));
     assert(equal(a, native_simd<int>(42 >> 4)));
   }
 }
 
+void test_relational_operators() {
+  fixed_size_simd<int, 9> a, b;
+  {
+    int buf[] = {1, 1, 1, 2, 2, 2, 3, 3, 3};
+    a.copy_from(buf, element_aligned_tag());
+  }
+  {
+    int buf[] = {1, 2, 3, 1, 2, 3, 1, 2, 3};
+    b.copy_from(buf, element_aligned_tag());
+  }
+  {
+    bool expected[] = {
+      true, false, false,
+      false, true, false,
+      false, false, true,
+    };
+    assert(all_of((a == b) == fixed_size_simd_mask<int, 9>(
+                                  expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {
+      false, true, true,
+      true, false, true,
+      true, true, false,
+    };
+    assert(all_of((a != b) == fixed_size_simd_mask<int, 9>(
+                                  expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {
+      false, true, true,
+      false, false, true,
+      false, false, false,
+    };
+    assert(all_of((a < b) == fixed_size_simd_mask<int, 9>(
+                                 expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {
+      true, true, true,
+      false, true, true,
+      false, false, true,
+    };
+    assert(all_of((a <= b) == fixed_size_simd_mask<int, 9>(
+                                  expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {
+      false, false, false,
+      true, false, false,
+      true, true, false,
+    };
+    assert(all_of((a > b) == fixed_size_simd_mask<int, 9>(
+                                 expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {
+      true, false, false,
+      true, true, false,
+      true, true, true,
+    };
+    assert(all_of((a >= b) == fixed_size_simd_mask<int, 9>(
+                                  expected, element_aligned_tag())));
+  }
+}
+
 int main() {
   test_pure_operators();
   test_mutating_opreators();
+  test_relational_operators();
 }

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// scalar access [simd.mask.subscr]
+// reference operator[](size_t);
+// value_type operator[](size_t) const;
+
+#include <experimental/simd>
+#include <cassert>
+#include <cstdint>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_access() {
+  {
+    fixed_size_simd_mask<int, 2> a(false), b(true);
+
+    assert(bool(a[0]) == false);
+    assert(bool(!a[0]) == true);
+    assert(bool(~a[0]) == true);
+    assert(bool(+a[0]) == false);
+    assert(bool(-a[0]) == false);
+    assert(bool(a[0] + b[0]) == true);
+    assert(bool(a[0] - b[0]) == true);
+    assert(bool(a[0] * b[0]) == false);
+    assert(bool(a[0] / b[0]) == false);
+    assert(bool(a[0] % b[0]) == false);
+    assert(bool(a[0] << b[0]) == false);
+    assert(bool(a[0] >> b[0]) == false);
+    assert(bool(a[0] < b[0]) == true);
+    assert(bool(a[0] <= b[0]) == true);
+    assert(bool(a[0] > b[0]) == false);
+    assert(bool(a[0] >= b[0]) == false);
+    assert(bool(a[0] == b[0]) == false);
+    assert(bool(a[0] != b[0]) == true);
+    assert(bool((a[0] & b[0])) == false);
+    assert(bool((a[0] | b[0])) == true);
+    assert(bool((a[0] ^ b[0])) == true);
+    assert(bool((a[0] && b[0])) == false);
+    assert(bool((a[0] || b[0])) == true);
+
+    {
+      auto c = a;
+      ++c[0];
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      auto ret = c[0]++;
+      assert(ret == false);
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      --c[0];
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      auto ret = c[0]--;
+      assert(ret == false);
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+
+    {
+      auto c = a;
+      c[0] += b[0];
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      c[0] -= b[0];
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = b;
+      c[0] *= a[0];
+      assert(bool(c[0]) == false);
+      assert(bool(c[1]) == true);
+    }
+    {
+      auto c = a;
+      c[0] /= b[0];
+      assert(bool(c[0]) == false);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      c[0] %= b[0];
+      assert(bool(c[0]) == false);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      c[0] >>= b[0];
+      assert(bool(c[0]) == false);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      c[0] <<= b[0];
+      assert(bool(c[0]) == false);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      c[0] &= b[0];
+      assert(bool(c[0]) == false);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      c[0] |= b[0];
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+    {
+      auto c = a;
+      c[0] ^= b[0];
+      assert(bool(c[0]) == true);
+      assert(bool(c[1]) == false);
+    }
+
+    {
+      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]));
+    }
+    {
+      auto c = a;
+      (void)(a[0] + (c[0] |= a[0]));
+    }
+    {
+      auto c = a;
+      (void)(a[0] + (c[0] ^= a[0]));
+    }
+  }
+  {
+    const fixed_size_simd_mask<int, 2> a(false), b(true);
+
+    assert(bool(a[0]) == false);
+    assert(bool(!a[0]) == true);
+    assert(bool(~a[0]) == true);
+    assert(bool(+a[0]) == false);
+    assert(bool(-a[0]) == false);
+    assert(bool(a[0] + b[0]) == true);
+    assert(bool(a[0] - b[0]) == true);
+    assert(bool(a[0] * b[0]) == false);
+    assert(bool(a[0] / b[0]) == false);
+    assert(bool(a[0] % b[0]) == false);
+    assert(bool(a[0] << b[0]) == false);
+    assert(bool(a[0] >> b[0]) == false);
+    assert(bool(a[0] < b[0]) == true);
+    assert(bool(a[0] <= b[0]) == true);
+    assert(bool(a[0] > b[0]) == false);
+    assert(bool(a[0] >= b[0]) == false);
+    assert(bool(a[0] == b[0]) == false);
+    assert(bool(a[0] != b[0]) == true);
+    assert(bool((a[0] & b[0])) == false);
+    assert(bool((a[0] | b[0])) == true);
+    assert(bool((a[0] ^ b[0])) == true);
+    assert(bool((a[0] && b[0])) == false);
+    assert(bool((a[0] || b[0])) == true);
+  }
+}
+
+int main() { test_access(); }

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// [simd.mask.class]
+// broadcast constructor
+// explicit simd_mask(value_type) noexcept;
+
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_broadcast() {
+  {
+    native_simd_mask<int> m(false);
+    for (size_t i = 0; i < m.size(); i++) {
+      assert(!m[i]);
+    }
+  }
+  {
+    native_simd_mask<int> m(true);
+    for (size_t i = 0; i < m.size(); i++) {
+      assert(m[i]);
+    }
+  }
+}
+
+int main() { test_broadcast(); }

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// [simd.mask.class]
+// simd() = default;
+
+#include <cstdint>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+int main() { (void)native_simd_mask<int32_t>(); }

libcxx/test/std/experimental/simd/simd.mask.cons/fixed_size_conversion.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// [simd.mask.class]
+// implicit type conversion constructor
+// template <class U> simd(const simd<U, simd_abi::fixed_size<size()>>&);
+
+#include <cstdint>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_fixed_size_conversion() {
+  {
+    fixed_size_simd_mask<float, 4> m = fixed_size_simd_mask<int, 4>(false);
+    for (size_t i = 0; i < m.size(); i++) {
+      assert(!m[i]);
+    }
+  }
+  {
+    fixed_size_simd_mask<float, 4> m = fixed_size_simd_mask<int, 4>(true);
+    for (size_t i = 0; i < m.size(); i++) {
+      assert(m[i]);
+    }
+  }
+}
+
+int main() { test_fixed_size_conversion(); }

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// [simd.mask.class]
+// load constructor
+// template <class Flags> simd_mask(const value_type* mem, Flags);
+
+#include <experimental/simd>
+
+#include "test_macros.h"
+
+using namespace std::experimental::parallelism_v2;
+
+void test_load_ctor() {
+  {
+    bool buf[] = {false, true, true, false};
+    fixed_size_simd_mask<int, 4> m(buf, element_aligned_tag());
+    assert(buf[0] == m[0]);
+    assert(buf[1] == m[1]);
+    assert(buf[2] == m[2]);
+    assert(buf[3] == m[3]);
+  }
+  {
+    bool buf[] = {false, true, true, false};
+    fixed_size_simd_mask<int, 4> m(buf, vector_aligned_tag());
+    assert(buf[0] == m[0]);
+    assert(buf[1] == m[1]);
+    assert(buf[2] == m[2]);
+    assert(buf[3] == m[3]);
+  }
+  {
+    bool buf[] = {false, true, true, false};
+    fixed_size_simd_mask<int, 4> m(buf, overaligned_tag<32>());
+    assert(buf[0] == m[0]);
+    assert(buf[1] == m[1]);
+    assert(buf[2] == m[2]);
+    assert(buf[3] == m[3]);
+  }
+#if TEST_STD_VER > 14
+  {
+    bool buf[] = {false, true, true, false};
+    fixed_size_simd_mask<int, 4> m(buf, element_aligned);
+    assert(buf[0] == m[0]);
+    assert(buf[1] == m[1]);
+    assert(buf[2] == m[2]);
+    assert(buf[3] == m[3]);
+  }
+  {
+    bool buf[] = {false, true, true, false};
+    fixed_size_simd_mask<int, 4> m(buf, vector_aligned);
+    assert(buf[0] == m[0]);
+    assert(buf[1] == m[1]);
+    assert(buf[2] == m[2]);
+    assert(buf[3] == m[3]);
+  }
+  {
+    bool buf[] = {false, true, true, false};
+    fixed_size_simd_mask<int, 4> m(buf, overaligned<32>);
+    assert(buf[0] == m[0]);
+    assert(buf[1] == m[1]);
+    assert(buf[2] == m[2]);
+    assert(buf[3] == m[3]);
+  }
+#endif
+}
+
+int main() { test_load_ctor(); }

libcxx/test/std/experimental/simd/simd.mask.elementwise/operators.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// [simd.mask.class]
+// // 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;
+
+#include <cstdint>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_pure_operators() {
+  assert(all_of(!simd_mask<int>(false)));
+  assert(all_of(simd_mask<int>(false) ==
+                (simd_mask<int>(false) && simd_mask<int>(true))));
+  assert(all_of(simd_mask<int>(true) ==
+                (simd_mask<int>(false) || simd_mask<int>(true))));
+  assert(all_of(simd_mask<int>(false) ==
+                (simd_mask<int>(false) & simd_mask<int>(true))));
+  assert(all_of(simd_mask<int>(true) ==
+                (simd_mask<int>(false) | simd_mask<int>(true))));
+  assert(all_of(simd_mask<int>(true) ==
+                (simd_mask<int>(false) ^ simd_mask<int>(true))));
+  assert(all_of(simd_mask<int>(false) ==
+                (simd_mask<int>(true) ^ simd_mask<int>(true))));
+}
+
+void test_mutating_opreators() {
+  {
+    simd_mask<int> a(true);
+    a &= simd_mask<int>(false);
+    assert(all_of(simd_mask<int>(false) == a));
+  }
+  {
+    simd_mask<int> a(true);
+    a |= simd_mask<int>(false);
+    assert(all_of(simd_mask<int>(true) == a));
+  }
+  {
+    simd_mask<int> a(true);
+    a ^= simd_mask<int>(false);
+    assert(all_of(simd_mask<int>(true) == a));
+  }
+  {
+    simd_mask<int> a(true);
+    a ^= simd_mask<int>(true);
+    assert(all_of(simd_mask<int>(false) == a));
+  }
+}
+
+void test_relational_operators() {
+  assert(all_of(!(simd_mask<int>(false) == simd_mask<int>(true))));
+  assert(all_of(simd_mask<int>(false) != simd_mask<int>(true)));
+  assert(all_of(simd_mask<int>(false) == simd_mask<int>(false)));
+  assert(all_of(!(simd_mask<int>(false) != simd_mask<int>(false))));
+  assert(all_of(simd_mask<int>(true) == simd_mask<int>(true)));
+  assert(all_of(!(simd_mask<int>(true) != simd_mask<int>(true))));
+}
+
+int main() {
+  test_pure_operators();
+  test_mutating_opreators();
+  test_relational_operators();
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// loads [simd.mask.copy]
+// template <class Flags> void copy_from(const value_type* mem, Flags);
+
+#include <experimental/simd>
+#include <cstdint>
+
+#include "test_macros.h"
+
+using namespace std::experimental::parallelism_v2;
+
+template <class T, class... Args>
+auto not_supported_load(Args&&... args) -> decltype(
+    std::declval<native_simd_mask<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<native_simd_mask<T>>().copy_from(std::forward<Args>(args)...),
+    void()) {}
+
+template <class T>
+void supported_load(...) = delete;
+
+void compile_load() {
+  supported_load<int>((bool*)nullptr, element_aligned_tag());
+  supported_load<uint32_t>((bool*)nullptr, element_aligned_tag());
+  supported_load<double>((bool*)nullptr, element_aligned_tag());
+  supported_load<uint16_t>((bool*)nullptr, element_aligned_tag());
+  supported_load<uint32_t>((bool*)nullptr, element_aligned_tag());
+
+  not_supported_load<int>((bool*)nullptr, int());
+}
+
+void test_load() {
+  alignas(32) bool buffer[] = {false, true, true, false};
+  {
+    fixed_size_simd_mask<int32_t, 4> a;
+    a.copy_from(buffer, element_aligned_tag());
+    assert(!a[0]);
+    assert(a[1]);
+    assert(a[2]);
+    assert(!a[3]);
+  }
+  {
+    fixed_size_simd_mask<int32_t, 4> a;
+    a.copy_from(buffer, vector_aligned_tag());
+    assert(!a[0]);
+    assert(a[1]);
+    assert(a[2]);
+    assert(!a[3]);
+  }
+  {
+    fixed_size_simd_mask<int32_t, 4> a;
+    a.copy_from(buffer, overaligned_tag<32>());
+    assert(!a[0]);
+    assert(a[1]);
+    assert(a[2]);
+    assert(!a[3]);
+  }
+
+#if TEST_STD_VER > 14
+  {
+    fixed_size_simd_mask<int32_t, 4> a;
+    a.copy_from(buffer, element_aligned);
+    assert(!a[0]);
+    assert(a[1]);
+    assert(a[2]);
+    assert(!a[3]);
+  }
+  {
+    fixed_size_simd_mask<int32_t, 4> a;
+    a.copy_from(buffer, vector_aligned);
+    assert(!a[0]);
+    assert(a[1]);
+    assert(a[2]);
+    assert(!a[3]);
+  }
+  {
+    fixed_size_simd_mask<int32_t, 4> a;
+    a.copy_from(buffer, overaligned<32>);
+    assert(!a[0]);
+    assert(a[1]);
+    assert(a[2]);
+    assert(!a[3]);
+  }
+#endif
+}
+
+int main() { test_load(); }

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// loads [simd.mask.copy]
+// template <class Flags> void copy_to(value_type* mem, Flags) const;
+
+#include <experimental/simd>
+
+#include "test_macros.h"
+
+using namespace std::experimental::parallelism_v2;
+
+void test_store() {
+  fixed_size_simd_mask<int, 4> a;
+  a[0] = false;
+  a[1] = true;
+  a[2] = true;
+  a[3] = false;
+  {
+    alignas(32) bool buffer[4] = {0};
+    a.copy_to(buffer, element_aligned_tag());
+    assert(!buffer[0]);
+    assert(buffer[1]);
+    assert(buffer[2]);
+    assert(!buffer[3]);
+  }
+  {
+    alignas(32) bool buffer[4] = {0};
+    a.copy_to(buffer, vector_aligned_tag());
+    assert(!buffer[0]);
+    assert(buffer[1]);
+    assert(buffer[2]);
+    assert(!buffer[3]);
+  }
+  {
+    alignas(32) bool buffer[4] = {0};
+    a.copy_to(buffer, overaligned_tag<32>());
+    assert(!buffer[0]);
+    assert(buffer[1]);
+    assert(buffer[2]);
+    assert(!buffer[3]);
+  }
+
+#if TEST_STD_VER > 14
+  {
+    alignas(32) bool buffer[4] = {0};
+    a.copy_to(buffer, element_aligned);
+    assert(!buffer[0]);
+    assert(buffer[1]);
+    assert(buffer[2]);
+    assert(!buffer[3]);
+  }
+  {
+    alignas(32) bool buffer[4] = {0};
+    a.copy_to(buffer, vector_aligned);
+    assert(!buffer[0]);
+    assert(buffer[1]);
+    assert(buffer[2]);
+    assert(!buffer[3]);
+  }
+  {
+    alignas(32) bool buffer[4] = {0};
+    a.copy_to(buffer, overaligned<32>);
+    assert(!buffer[0]);
+    assert(buffer[1]);
+    assert(buffer[2]);
+    assert(!buffer[3]);
+  }
+#endif
+}
+
+int main() { test_store(); }