[libcxx] implement <experimental/simd> simd_mask<> casts and some horizontal operations.

[timshen]

Summary

popcount is implemented in terms of for loop. On x86, it can be specialized to _mm_movemask_* + __builtin_popcountll() in the future.

[timshen]

Add tests to boolean version of the horizontal operations.

[timshen]

Rebased.

[timshen]

Rebase.

libcxx/include/experimental/simd

 }
 
 template <class _Tp, class _Abi>
 fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>
 to_fixed_size(const simd<_Tp, _Abi>& __v) noexcept {
   return simd_cast<fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>>(__v);
 }
 
-template <class _Tp, class _Abi>
-fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
-to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;
-
 // NOTE: As an extension, allow transforming to a native type with a size
 // that's not native_simd<T>::size().
 template <class _Tp, size_t _Np>
 simd<_Tp, simd_abi::__native<_Tp, _Np>>
 to_native(const fixed_size_simd<_Tp, _Np>& __v) noexcept {
   return simd_cast<simd<_Tp, simd_abi::__native<_Tp, _Np>>>(__v);
 }
 
-template <class _Tp, size_t _Np>
-native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
-
 // NOTE: As an extension, allow transforming to a compatible type with a size
 // that's not simd<T>::size().
 template <class _Tp, size_t _Np>
 simd<_Tp, simd_abi::__compatible<_Tp, _Np>>
 to_compatible(const fixed_size_simd<_Tp, _Np>& __v) noexcept {
   return simd_cast<simd<_Tp, simd_abi::__compatible<_Tp, _Np>>>(__v);
 }
 
-template <class _Tp, size_t _Np>
-simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
-
-template <class _TupleType, class _Tp, size_t... __indicies>
+template <class _TupleType, class _Tp, size_t... __indices>
 _TupleType __split_tuple_impl(_Tp** __buffers,
-                              std::index_sequence<__indicies...>) {
-  return _TupleType(typename std::tuple_element<__indicies, _TupleType>::type(
-      __buffers[__indicies], element_aligned_tag())...);
+                              std::index_sequence<__indices...>) {
+  return _TupleType(typename std::tuple_element<__indices, _TupleType>::type(
+      __buffers[__indices], element_aligned_tag())...);
 }
 
 template <size_t... __sizes, class _Tp, class _Abi>
 typename std::enable_if<
     __variadic_sum<size_t>(__sizes...) == simd<_Tp, _Abi>::size(),
     tuple<simd<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>::type
 split(const simd<_Tp, _Abi>& __v) {
   _Tp __buffer[__v.size()];
_Tp* __buffers[sizeof...(__sizes)];
     }
   }
 
   return __split_tuple_impl<
       tuple<simd<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>(
       __buffers, std::make_index_sequence<sizeof...(__sizes)>());
 }
 
-template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>
-split(const simd_mask<_Tp, _Abi>&);
-
 // NOTE: P0820 extension
 template <size_t __array_size, class _Tp, class _Abi>
 typename std::enable_if<
     simd_size<_Tp, _Abi>::value % __array_size == 0,
     array<simd<_Tp, rebind_abi_t<
                         _Tp, simd_size<_Tp, _Abi>::value / __array_size, _Abi>>,
           __array_size>>::type
 split_by(const simd<_Tp, _Abi>& __v) {
is_simd<_SimdType>::value &&
             0,
     array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
                          _SimdType::size()>>::type
 split(const simd<typename _SimdType::value_type, _Abi>& __v) {
   return split_by<simd_size<typename _SimdType::value_type, _Abi>::value /
                   _SimdType::size()>(__v);
 }
 
-template <size_t __array_size, class _Tp, class _Abi>
-array<
-    simd_mask<_Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
-                                _Abi>>,
-    __array_size>
-split_by(const simd_mask<_Tp, _Abi>& x);
-
-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 <class _TupleType, class _Tp, size_t... __indicies>
+template <class _TupleType, class _Tp, size_t... __indices>
 void __concat_tuple_impl(_TupleType __vs, _Tp** __buffers,
-                         std::index_sequence<__indicies...>) {
-  int __unused[] = {(std::get<__indicies>(__vs).copy_to(__buffers[__indicies],
-                                                        element_aligned_tag()),
+                         std::index_sequence<__indices...>) {
+  int __unused[] = {(std::get<__indices>(__vs).copy_to(__buffers[__indices],
                      0)...};
   (void)__unused;
 }
 
 template <class _Tp, class... _Abis>
 simd<_Tp,
      rebind_abi_t<_Tp, __variadic_sum<size_t>(simd_size<_Tp, _Abis>::value...),
                   _Abis...>>
concat(const std::array<simd<_Tp, _Abi>, _Np>& __arr) {
   simd<_Tp, rebind_abi_t<_Tp, _Np * simd<_Tp, _Abi>::size(), _Abi>> __v;
   for (size_t __i = 0; __i < __v.size(); __i++) {
     __v[__i] =
         __arr[__i / simd<_Tp, _Abi>::size()][__i % simd<_Tp, _Abi>::size()];
   }
   return __v;
 }
 
+struct __simd_mask_friend {
+  template <class _Tp, class _Abi>
+  static fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
+  __to_fixed_size(const simd_mask<_Tp, _Abi>& __m) noexcept {
+    return to_fixed_size(__m.__s_);
+  }
+
+  template <class _Tp, size_t _Np>
+  static simd_mask<_Tp, simd_abi::__native<_Tp, _Np>>
+  __to_native(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+    return to_native(__m.__s_);
+  }
+
+  template <class _Tp, size_t _Np>
+  static simd_mask<_Tp, simd_abi::__compatible<_Tp, _Np>>
+  __to_compatible(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+    return to_compatible(__m.__s_);
+  }
+
+  template <class _ResType, class _TupleType, size_t... __indices>
+  static _ResType __split_impl(const _TupleType& __t,
+                               std::index_sequence<__indices...>) {
+    return _ResType(std::get<__indices>(__t)...);
+  }
+
+  template <size_t... __sizes, class _Tp, class _Abi>
+  static typename std::enable_if<
+      __variadic_sum<size_t>(__sizes...) == simd<_Tp, _Abi>::size(),
+      tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>::type
+  __split(const simd_mask<_Tp, _Abi>& __m) {
+    return __split_impl<
+        tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>(
+        split<__sizes...>(__m.__s_),
+        std::make_index_sequence<sizeof...(__sizes)>());
+  }
+
+  template <size_t __array_size, class _Tp, class _Abi>
+  static typename std::enable_if<
+      simd_size<_Tp, _Abi>::value % __array_size == 0,
+      array<simd_mask<_Tp, rebind_abi_t<
+                               _Tp, simd_size<_Tp, _Abi>::value / __array_size,
+                               _Abi>>,
+            __array_size>>::type
+  __split_by(const simd_mask<_Tp, _Abi>& __m) {
+    auto __arr = split_by<__array_size>(__m.__s_);
+    array<simd_mask<
+              _Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
+                                _Abi>>,
+          __array_size>
+        __ret;
+    for (size_t __i = 0; __i < __ret.size(); __i++) {
+      __ret[__i] = __arr[__i];
+    }
+    return __ret;
+  }
+
+  template <class _MaskType, class _Abi>
+  static typename std::enable_if<
+      is_simd_mask<_MaskType>::value &&
+          simd_size<typename _MaskType::value_type, _Abi>::value %
+                  _MaskType::size() ==
+              0,
+      array<_MaskType, simd_size<typename _MaskType::value_type, _Abi>::value /
+                           _MaskType::size()>>::type
+  __split(const simd_mask<typename _MaskType::value_type, _Abi>& __m) {
+    return split<typename _MaskType::simd_type>(__m.__s_);
+  }
+
+  template <class _Tp, class... _Abis>
+  static simd_mask<
+      _Tp,
+      rebind_abi_t<_Tp, __variadic_sum<size_t>(simd_size<_Tp, _Abis>::value...),
+                   _Abis...>>
+  __concat(const simd_mask<_Tp, _Abis>&... __ms) {
+    return concat(__ms.__s_...);
+  }
+
+  template <class _Tp, class _Abi, size_t _Np>
+  static simd_mask<_Tp,
+                   rebind_abi_t<_Tp, _Np * simd_size<_Tp, _Abi>::value, _Abi>>
+  __concat(const std::array<simd_mask<_Tp, _Abi>, _Np>& __ms) {
+    std::array<decltype(__ms[0].__s_), _Np> __arr;
+    for (size_t __i = 0; __i < __ms.size(); __i++) {
+      __arr[__i] = __ms[__i].__s_;
+    }
+    return concat(__arr);
+  }
+};
+
+template <class _Tp, class _Abi>
+fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
+to_fixed_size(const simd_mask<_Tp, _Abi>& __m) noexcept {
+  return __simd_mask_friend::__to_fixed_size(__m);
+}
+
+template <class _Tp, size_t _Np>
+simd_mask<_Tp, simd_abi::__native<_Tp, _Np>>
+to_native(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+  return __simd_mask_friend::__to_native(__m);
+}
+
+template <class _Tp, size_t _Np>
+simd_mask<_Tp, simd_abi::__compatible<_Tp, _Np>>
+to_compatible(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+  return __simd_mask_friend::__to_compatible(__m);
+}
+
+template <size_t... __sizes, class _Tp, class _Abi>
+typename std::enable_if<
+    __variadic_sum<size_t>(__sizes...) == simd<_Tp, _Abi>::size(),
+    tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>::type
+split(const simd_mask<_Tp, _Abi>& __m) {
+  return __simd_mask_friend::__split<__sizes...>(__m);
+}
+
+template <size_t __array_size, class _Tp, class _Abi>
+static typename std::enable_if<
+    simd_size<_Tp, _Abi>::value % __array_size == 0,
+    array<simd_mask<
+              _Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
+                                _Abi>>,
+          __array_size>>::type
+split_by(const simd_mask<_Tp, _Abi>& __m) {
+  return __simd_mask_friend::__split_by<__array_size>(__m);
+}
+
+template <class _MaskType, class _Abi>
+static typename std::enable_if<
+    is_simd_mask<_MaskType>::value &&
+        simd_size<typename _MaskType::value_type, _Abi>::value %
+                _MaskType::size() ==
+            0,
+    array<_MaskType, simd_size<typename _MaskType::value_type, _Abi>::value /
+                         _MaskType::size()>>::type
+split(const simd_mask<typename _MaskType::value_type, _Abi>& __m) {
+  return __simd_mask_friend::__split<_MaskType>(__m);
+}
+
 template <class _Tp, class... _Abis>
 simd_mask<_Tp, rebind_abi_t<
                    _Tp, __variadic_sum<size_t>(simd_size<_Tp, _Abis>::value...),
                    _Abis...>>
-concat(const simd_mask<_Tp, _Abis>&...);
+concat(const simd_mask<_Tp, _Abis>&... __ms) {
+  return __simd_mask_friend::__concat(__ms...);
+}
 
 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>&);
+simd_mask<_Tp, rebind_abi_t<_Tp, _Np * simd_size<_Tp, _Abi>::value, _Abi>>
+concat(const std::array<simd_mask<_Tp, _Abi>, _Np>& __ms) {
+  return __simd_mask_friend::__concat(__ms);
+}
 
 // reductions [simd.mask.reductions]
 template <class _Tp, class _Abi>
 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;
+bool any_of(const simd_mask<_Tp, _Abi>& __m) noexcept {
+  bool __ret = false;
+  for (size_t __i = 0; __i < __m.size(); __i++) {
+    __ret |= __m[__i];
+  }
+  return __ret;
+}
+
 template <class _Tp, class _Abi>
-bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;
+bool none_of(const simd_mask<_Tp, _Abi>& __m) noexcept {
+  return !any_of(__m);
+}
+
 template <class _Tp, class _Abi>
-bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;
+bool some_of(const simd_mask<_Tp, _Abi>& __m) noexcept {
+  return !all_of(__m) && !none_of(__m);
+}
+
 template <class _Tp, class _Abi>
-int popcount(const simd_mask<_Tp, _Abi>&) noexcept;
+int popcount(const simd_mask<_Tp, _Abi>& __m) noexcept {
+  int __ret = 0;
+  for (size_t __i = 0; __i < __m.size(); __i++) {
+    __ret += __m[__i];
+  }
+  return __ret;
+}
+
 template <class _Tp, class _Abi>
-int find_first_set(const simd_mask<_Tp, _Abi>&);
+int find_first_set(const simd_mask<_Tp, _Abi>& __m) {
+  for (size_t __i = 0; __i < __m.size(); __i++) {
+    if (__m[__i]) {
+      return __i;
+    }
+  }
+  return __m.size();
+}
+
 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;
+int find_last_set(const simd_mask<_Tp, _Abi>& __m) {
+  for (int __i = __m.size() - 1; __i >= 0; __i--) {
+    if (__m[__i]) {
+      return __i;
+    }
+  }
+  return __m.size();
+}
+
+bool all_of(bool __v) noexcept { return __v; }
+bool any_of(bool __v) noexcept { return __v; }
+bool none_of(bool __v) noexcept { return !__v; }
+bool some_of(bool) noexcept { return false; }
+int popcount(bool __v) noexcept { return __v; }
+int find_first_set(bool) noexcept { return 0; }
+int find_last_set(bool) noexcept { return 0; }
 
 // masked assignment [simd.whereexpr]
 template <class _MaskType, class _Tp>
 class const_where_expression;
 template <class _MaskType, class _Tp>
 class where_expression;
 
 // masked assignment [simd.mask.where]
return (std::is_arithmetic<_Up>::value &&
            (!std::is_arithmetic<_Up>::value &&
             std::is_convertible<_Up, _Tp>::value) ||
            std::is_same<typename std::remove_const<_Up>::type, int>::value ||
            (std::is_same<typename std::remove_const<_Up>::type,
                          unsigned int>::value &&
             std::is_unsigned<_Tp>::value);
   }
 
-  template <class _Generator, size_t... __indicies>
+  template <class _Generator, size_t... __indices>
   static constexpr decltype(
       std::forward_as_tuple(std::declval<_Generator>()(
-          std::integral_constant<size_t, __indicies>())...),
+          std::integral_constant<size_t, __indices>())...),
       bool())
-  __can_generate(std::index_sequence<__indicies...>) {
+  __can_generate(std::index_sequence<__indices...>) {
     return !__variadic_sum<bool>(
         !__can_broadcast<decltype(std::declval<_Generator>()(
-            std::integral_constant<size_t, __indicies>()))>()...);
+            std::integral_constant<size_t, __indices>()))>()...);
   }
 
   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 __unused[] = {((*this)[__indicies] =
-                           __g(std::integral_constant<size_t, __indicies>()),
-                       0)...};
+  template <class _Generator, size_t... __indices>
+  void __generator_init(_Generator&& __g, std::index_sequence<__indices...>) {
+    int __unused[] = {
+        ((*this)[__indices] = __g(std::integral_constant<size_t, __indices>()),
     (void)__unused;
   }
 
 public:
   // implicit type conversion constructor
   template <class _Up,
             class = typename std::enable_if<
                 std::is_same<_Abi, simd_abi::fixed_size<size()>>::value &&

 // [simd.mask.class]
 template <class _Tp, class _Abi>
 class simd_mask {
   using __element_type = typename __unsigned_traits<sizeof(_Tp)>::type;
   using __ref_traits = __simd_ref_traits<bool, __element_type, _Abi>;
 
   simd<__element_type, _Abi> __s_;
 
-  explicit simd_mask(const simd<__element_type, _Abi>& __mask) : __s_(__mask) {}
+  simd_mask(const simd<__element_type, _Abi>& __mask) : __s_(__mask) {}
+
+  friend struct __simd_mask_friend;
 
 public:
   using value_type = bool;
   using reference = typename __ref_traits::type;
   using simd_type = simd<_Tp, _Abi>;
   using abi_type = _Abi;
 
   static constexpr size_t size() noexcept {

libcxx/test/std/experimental/simd/simd.horizontal/concat.pass.cpp

 // concat(const std::array<simd_mask<T, Abi>, N>&);
 
 #include <experimental/simd>
 #include <cassert>
 #include <cstdint>
 
 using namespace std::experimental::parallelism_v2;
 
-void test_concat() {
+void test_concat_simd() {
   auto v = concat(fixed_size_simd<int, 1>([](int i) { return i; }),
                   fixed_size_simd<int, 2>([](int i) { return i + 1; }),
                   fixed_size_simd<int, 3>([](int i) { return i + 3; }));
   static_assert(v.size() == 6, "");
   assert(v[0] == 0);
   assert(v[1] == 1);
   assert(v[2] == 2);
   assert(v[3] == 3);
   assert(v[4] == 4);
   assert(v[5] == 5);
 }
 
-void test_concat_array() {
+void test_concat_mask() {
+  auto v = concat(fixed_size_simd_mask<int, 1>(true),
+                  fixed_size_simd_mask<int, 2>(true),
+                  fixed_size_simd_mask<int, 3>(true));
+  static_assert(v.size() == 6, "");
+  assert(v[0]);
+  assert(v[1]);
+  assert(v[2]);
+  assert(v[3]);
+  assert(v[4]);
+  assert(v[5]);
+}
+
+void test_concat_array_simd() {
   std::array<fixed_size_simd<int, 2>, 2> arr;
   arr[0] = fixed_size_simd<int, 2>([](int) { return 0; });
   arr[1] = fixed_size_simd<int, 2>([](int) { return 1; });
 
   auto v = concat(arr);
   static_assert(v.size() == 4, "");
   assert(v[0] == 0);
   assert(v[1] == 0);
   assert(v[2] == 1);
   assert(v[3] == 1);
 }
 
+void test_concat_array_mask() {
+  std::array<fixed_size_simd_mask<int, 2>, 2> arr;
+  arr[0] = fixed_size_simd_mask<int, 2>(true);
+  arr[1] = fixed_size_simd_mask<int, 2>(true);
+
+  auto v = concat(arr);
+  static_assert(v.size() == 4, "");
+  assert(v[0]);
+  assert(v[1]);
+  assert(v[2]);
+  assert(v[3]);
+}
+
 void compile_split_propagate_abi() {
   static_assert(std::is_same<typename decltype(
                                  concat(simd<int>(), simd<int>()))::abi_type,
                              rebind_abi_t<int, simd<int>::size() * 2,
                                           simd_abi::compatible<int>>>::value,
                 "");
 
   static_assert(
       std::is_same<typename decltype(concat(native_simd<int>(),
                                             native_simd<int>()))::abi_type,
                    rebind_abi_t<int, native_simd<int>::size() * 2,
                                 simd_abi::native<int>>>::value,
       "");
 }
 
 int main() {
-  test_concat();
-  test_concat_array();
+  test_concat_simd();
+  test_concat_mask();
+  test_concat_array_simd();
+  test_concat_array_mask();
 }

libcxx/test/std/experimental/simd/simd.horizontal/mask.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>
+//
+// // 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>&);
+//
+// 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;
+
+#include <cassert>
+#include <cstdint>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_all_of() {
+  {
+    bool expected[] = {false, false};
+    assert(
+        !all_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, false};
+    assert(
+        !all_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, true};
+    assert(
+        all_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+}
+
+void test_any_of() {
+  {
+    bool expected[] = {false, false};
+    assert(
+        !any_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, false};
+    assert(
+        any_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, true};
+    assert(
+        any_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+}
+
+void test_none_of() {
+  {
+    bool expected[] = {false, false};
+    assert(
+        none_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, false};
+    assert(!none_of(
+        fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, true};
+    assert(!none_of(
+        fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+}
+
+void test_some_of() {
+  {
+    bool expected[] = {false, false};
+    assert(!some_of(
+        fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, false};
+    assert(
+        some_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+  {
+    bool expected[] = {true, true};
+    assert(!some_of(
+        fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+  }
+}
+
+void test_popcount() {
+  {
+    bool expected[] = {false, false};
+    assert(popcount(fixed_size_simd_mask<int, 2>(expected,
+                                                 element_aligned_tag())) == 0);
+  }
+  {
+    bool expected[] = {true, false};
+    assert(popcount(fixed_size_simd_mask<int, 2>(expected,
+                                                 element_aligned_tag())) == 1);
+  }
+  {
+    bool expected[] = {true, true};
+    assert(popcount(fixed_size_simd_mask<int, 2>(expected,
+                                                 element_aligned_tag())) == 2);
+  }
+}
+
+void test_find_first_set() {
+  {
+    bool expected[] = {false, true, true};
+    assert(find_first_set(fixed_size_simd_mask<int, 3>(
+               expected, element_aligned_tag())) == 1);
+  }
+  {
+    bool expected[] = {true, false, true};
+    assert(find_first_set(fixed_size_simd_mask<int, 3>(
+               expected, element_aligned_tag())) == 0);
+  }
+  {
+    bool expected[] = {true, true, false};
+    assert(find_first_set(fixed_size_simd_mask<int, 3>(
+               expected, element_aligned_tag())) == 0);
+  }
+}
+
+void test_find_last_set() {
+  {
+    bool expected[] = {false, true, true};
+    assert(find_last_set(fixed_size_simd_mask<int, 3>(
+               expected, element_aligned_tag())) == 2);
+  }
+  {
+    bool expected[] = {true, false, true};
+    assert(find_last_set(fixed_size_simd_mask<int, 3>(
+               expected, element_aligned_tag())) == 2);
+  }
+  {
+    bool expected[] = {true, true, false};
+    assert(find_last_set(fixed_size_simd_mask<int, 3>(
+               expected, element_aligned_tag())) == 1);
+  }
+}
+
+void test_bool_functions() {
+  assert(all_of(true));
+  assert(!all_of(false));
+  assert(any_of(true));
+  assert(!any_of(false));
+  assert(!none_of(true));
+  assert(none_of(false));
+  assert(!some_of(true));
+  assert(!some_of(false));
+  assert(popcount(true) == 1);
+  assert(popcount(false) == 0);
+  assert(find_first_set(true) == 0);
+  assert(find_first_set(false) == 0);
+  assert(find_last_set(true) == 0);
+  assert(find_last_set(false) == 0);
+}
+
+int main() {
+  test_all_of();
+  test_any_of();
+  test_none_of();
+  test_some_of();
+  test_popcount();
+  test_find_first_set();
+  test_find_last_set();
+  test_bool_functions();
+}

libcxx/test/std/experimental/simd/simd.horizontal/split.pass.cpp

 //     const simd_mask<T, A>& x);
 
 #include <experimental/simd>
 #include <cassert>
 #include <cstdint>
 
 using namespace std::experimental::parallelism_v2;
 
-void test_split() {
+void test_split_simd() {
   auto t = split<1, 2, 3>(fixed_size_simd<int, 6>([](int i) { return i; }));
   static_assert(std::tuple_size<decltype(t)>::value == 3, "");
 
   assert(std::get<0>(t).size() == 1);
   assert(std::get<0>(t)[0] == 0);
 
   assert(std::get<1>(t).size() == 2);
   assert(std::get<1>(t)[0] == 1);
   assert(std::get<1>(t)[1] == 2);
 
   assert(std::get<2>(t).size() == 3);
   assert(std::get<2>(t)[0] == 3);
   assert(std::get<2>(t)[1] == 4);
   assert(std::get<2>(t)[2] == 5);
 }
 
-void test_split_array() {
+void test_split_mask() {
+  auto t = split<1, 2, 3>(fixed_size_simd_mask<int, 6>(true));
+  static_assert(std::tuple_size<decltype(t)>::value == 3, "");
+
+  assert(std::get<0>(t).size() == 1);
+  assert(std::get<0>(t)[0]);
+
+  assert(std::get<1>(t).size() == 2);
+  assert(std::get<1>(t)[0]);
+  assert(std::get<1>(t)[1]);
+
+  assert(std::get<2>(t).size() == 3);
+  assert(std::get<2>(t)[0]);
+  assert(std::get<2>(t)[1]);
+  assert(std::get<2>(t)[2]);
+}
+
+void test_split_array_simd() {
   {
     auto arr = split_by<2>(fixed_size_simd<int, 6>([](int i) { return i; }));
     static_assert(arr.size() == 2, "");
 
     assert(arr[0].size() == 3);
     assert(arr[0][0] == 0);
     assert(arr[0][1] == 1);
     assert(arr[0][2] == 2);
void test_split_array_simd() {
 
     assert(arr[1].size() == 3);
     assert(arr[1][0] == 3);
     assert(arr[1][1] == 4);
     assert(arr[1][2] == 5);
   }
 }
 
-void compile_split_propagate_abi() {
+void test_split_array_mask() {
+  {
+    auto arr = split_by<2>(fixed_size_simd_mask<int, 6>(true));
+    static_assert(arr.size() == 2, "");
+
+    assert(arr[0].size() == 3);
+    assert(arr[0][0]);
+    assert(arr[0][1]);
+    assert(arr[0][2]);
+
+    assert(arr[1].size() == 3);
+    assert(arr[1][0]);
+    assert(arr[1][1]);
+    assert(arr[1][2]);
+  }
+  {
+    auto arr = split<fixed_size_simd<int, 3>>(fixed_size_simd<int, 6>(true));
+    static_assert(arr.size() == 2, "");
+
+    assert(arr[0].size() == 3);
+    assert(arr[0][0]);
+    assert(arr[0][1]);
+    assert(arr[0][2]);
+
+    assert(arr[1].size() == 3);
+    assert(arr[1][0]);
+    assert(arr[1][1]);
+    assert(arr[1][2]);
+  }
+}
+
+void compile_split_simd_propagate_abi() {
   using compatible_simd_half =
       simd<int,
            rebind_abi_t<int, simd<int>::size() / 2, simd_abi::compatible<int>>>;
   using native_simd_half =
       simd<int, rebind_abi_t<int, native_simd<int>::size() / 2,
                              simd_abi::native<int>>>;
 
   static_assert(
static_assert(std::is_same<decltype(split_by<2>(simd<int>())),
                              std::array<compatible_simd_half, 2>>::value,
                 "");
 
   static_assert(std::is_same<decltype(split_by<2>(native_simd<int>())),
                              std::array<native_simd_half, 2>>::value,
                 "");
 }
 
+void compile_split_simd_mask_propagate_abi() {
+  using compatible_simd_mask_half =
+      simd_mask<int, rebind_abi_t<int, simd_mask<int>::size() / 2,
+                                  simd_abi::compatible<int>>>;
+  using native_simd_mask_half =
+      simd_mask<int, rebind_abi_t<int, native_simd_mask<int>::size() / 2,
+                                  simd_abi::native<int>>>;
+
+  static_assert(std::is_same<decltype(split<simd_mask<int>::size() / 2,
+                                            simd_mask<int>::size() / 2>(
+                                 simd_mask<int>())),
+                             std::tuple<compatible_simd_mask_half,
+                                        compatible_simd_mask_half>>::value,
+                "");
+
+  static_assert(
+      std::is_same<
+          decltype(split<native_simd_mask<int>::size() / 2,
+                         native_simd_mask<int>::size() / 2>(
+              native_simd_mask<int>())),
+          std::tuple<native_simd_mask_half, native_simd_mask_half>>::value,
+      "");
+
+  static_assert(std::is_same<decltype(split_by<2>(simd_mask<int>())),
+                             std::array<compatible_simd_mask_half, 2>>::value,
+                "");
+
+  static_assert(std::is_same<decltype(split_by<2>(native_simd_mask<int>())),
+                             std::array<native_simd_mask_half, 2>>::value,
+                "");
+}
+
 int main() {
-  test_split();
-  test_split_array();
+  test_split_simd();
+  test_split_mask();
+  test_split_array_simd();
+  test_split_array_mask();
 }

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

 // to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;
 
 #include <experimental/simd>
 #include <cstdint>
 
 using namespace std::experimental::parallelism_v2;
 
 void test_to_compatible() {
+  {
     auto v = to_compatible(
         fixed_size_simd<int, simd<int>::size()>([](int i) { return i; }));
     simd<int> w([](int i) { return i; });
 
     static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
 
     for (size_t i = 0; i < v.size(); i++) {
       assert(v[i] == w[i]);
     }
   }
 
+  {
+    auto v =
+        to_compatible(fixed_size_simd_mask<int, simd_mask<int>::size()>(true));
+    static_assert(std::is_same<simd_mask<int>, decltype(v)>::value, "");
+    assert(all_of(v));
+  }
+}
+
 void test_to_compatible_extension() {
-  auto arr = split_by<32 / simd<int>::size()>(
-      to_compatible(fixed_size_simd<int, 32>([](int i) { return i; })));
-  static_assert(std::is_same<decltype(arr)::value_type, simd<int>>::value, "");
+  {
+    std::array<simd<int>, 2> arr = split_by<2>(to_compatible(
+        fixed_size_simd<int, simd<int>::size() * 2>([](int i) { return i; })));
+    static_assert(std::is_same<decltype(arr)::value_type, simd<int>>::value,
+                  "");
     int v = 0;
     for (size_t i = 0; i < arr.size(); i++) {
       for (size_t j = 0; j < arr[0].size(); j++) {
         assert(arr[i][j] == v);
         v++;
       }
     }
   }
+  {
+    std::array<simd_mask<int>, 2> arr = split_by<2>(to_compatible(
+        fixed_size_simd_mask<int, simd_mask<int>::size() * 2>(true)));
+    for (size_t i = 0; i < arr.size(); i++) {
+      for (size_t j = 0; j < arr[0].size(); j++) {
+        assert(arr[i][j]);
+      }
+    }
+  }
+}
 
 int main() {
   test_to_compatible();
   test_to_compatible_extension();
 }

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

 // to_fixed_size(const simd_mask<T, Abi>&) noexcept;
 
 #include <experimental/simd>
 #include <cstdint>
 
 using namespace std::experimental::parallelism_v2;
 
 void test_to_fixed_size() {
+  {
     auto v = to_fixed_size(native_simd<int>([](int i) { return i; }));
     static_assert(std::is_same<fixed_size_simd<int, native_simd<int>::size()>,
                                decltype(v)>::value,
                   "");
 
     for (size_t i = 0; i < v.size(); i++) {
       assert(v[i] == (int)i);
     }
   }
+  {
+    auto v = to_fixed_size(native_simd_mask<int>(true));
+    static_assert(
+        std::is_same<fixed_size_simd_mask<int, native_simd_mask<int>::size()>,
+                     decltype(v)>::value,
+        "");
+    assert(all_of(v));
+  }
+}
 
 int main() { test_to_fixed_size(); }

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

 // native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>&) noexcept;
 
 #include <experimental/simd>
 #include <cstdint>
 
 using namespace std::experimental::parallelism_v2;
 
 void test_to_native() {
-  auto v = to_native(
-      fixed_size_simd<int, native_simd<int>::size()>([](int i) { return i; }));
+  {
+    auto v = to_native(fixed_size_simd<int, native_simd<int>::size()>(
+        [](int i) { return i; }));
     native_simd<int> w([](int i) { return i; });
 
     static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
 
     for (size_t i = 0; i < v.size(); i++) {
       assert(v[i] == w[i]);
     }
   }
+  {
+    auto v = to_native(
+        fixed_size_simd_mask<int, native_simd_mask<int>::size()>(true));
+    static_assert(std::is_same<native_simd_mask<int>, decltype(v)>::value, "");
+    assert(all_of(v));
+  }
+}
 
 void test_to_native_extension() {
-  auto arr = split_by<32 / native_simd<int>::size()>(
-      to_native(fixed_size_simd<int, 32>([](int i) { return i; })));
+  {
+    std::array<native_simd<int>, 2> arr = split_by<2>(
+        to_native(fixed_size_simd<int, native_simd<int>::size() * 2>(
+            [](int i) { return i; })));
     static_assert(
         std::is_same<decltype(arr)::value_type, native_simd<int>>::value, "");
     int v = 0;
     for (size_t i = 0; i < arr.size(); i++) {
       for (size_t j = 0; j < arr[0].size(); j++) {
         assert(arr[i][j] == v);
         v++;
       }
     }
   }
+  {
+    std::array<native_simd_mask<int>, 2> arr = split_by<2>(to_native(
+        fixed_size_simd_mask<int, native_simd_mask<int>::size() * 2>(true)));
+    for (size_t i = 0; i < arr.size(); i++) {
+      for (size_t j = 0; j < arr[0].size(); j++) {
+        assert(arr[i][j]);
+      }
+    }
+  }
+}
 
 int main() {
   test_to_native();
   test_to_native_extension();
 }