[libcxx] <experimental/simd> Add generate constructor of class simd

[Joy12138]

Update status paper

[Joy12138]

Add SFINAE test

[Joy12138]

Rebase

[Joy12138]

Fix CI

[philnik]

Let's land the current stack and move this PR to GitHub.

libcxx/include/experimental/__simd/scalar.h

 struct __mask_storage<_Tp, simd_abi::__scalar> : __simd_storage<bool, simd_abi::__scalar> {};
 
 template <class _Tp>
 struct __simd_operations<_Tp, simd_abi::__scalar> {
   using _SimdStorage = __simd_storage<_Tp, simd_abi::__scalar>;
   using _MaskStorage = __mask_storage<_Tp, simd_abi::__scalar>;
 
   static _SimdStorage __broadcast(_Tp __v) noexcept { return {__v}; }
+
+  template <class _Generator>
+  static _SimdStorage __generate(_Generator&& __g) noexcept {
+    return {__g(std::integral_constant<size_t, 0>())};
+  }
 };
 
 template <class _Tp>
 struct __mask_operations<_Tp, simd_abi::__scalar> {
   using _MaskStorage = __mask_storage<_Tp, simd_abi::__scalar>;
 
   static _MaskStorage __broadcast(bool __v) noexcept { return {__v}; }
 };
 
 } // namespace parallelism_v2
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H

libcxx/include/experimental/__simd/simd.h

public:
   using abi_type   = _Abi;
 
   static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return simd_size_v<value_type, abi_type>; }
 
   // broadcast constructor
   template <class _Up, enable_if_t<__can_broadcast_v<value_type, __remove_cvref_t<_Up>>, int> = 0>
   _LIBCPP_HIDE_FROM_ABI simd(_Up&& __v) noexcept : __s_(_Impl::__broadcast(static_cast<value_type>(__v))) {}
 
+  // generator constructor
+  template <class _Generator,
+            enable_if_t<__can_generate<value_type, _Generator>(make_index_sequence<size()>()), int> = 0>
+  explicit _LIBCPP_HIDE_FROM_ABI simd(_Generator&& __g) : __s_(_Impl::__generate(std::forward<_Generator>(__g))) {}
+
   // scalar access [simd.subscr]
   // Add operator[] temporarily to test braodcast. Add test for it in later patch.
   _LIBCPP_HIDE_FROM_ABI value_type operator[](size_t __i) const { return __s_.__get(__i); }
 };
 
 template <class _Tp>
 using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
 
 template <class _Tp, int _Np>
 using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
 
 } // namespace parallelism_v2
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_SIMD_H

libcxx/include/experimental/__simd/utility.h

 #include <__type_traits/is_const.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_unsigned.h>
 #include <__type_traits/is_volatile.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
+#include <__utility/integer_sequence.h>
 #include <cstdint>
 #include <limits>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 
inline constexpr bool __is_non_narrowing_convertible_v<_From, _To, std::void_t<decltype(_To{std::declval<_From>()})>> =
     true;
 
 template <class _Tp, class _Up>
 inline constexpr bool __can_broadcast_v =
     (__is_vectorizable_v<_Up> && __is_non_narrowing_convertible_v<_Up, _Tp>) ||
     (!__is_vectorizable_v<_Up> && is_convertible_v<_Up, _Tp>) || is_same_v<_Up, int> ||
     (is_same_v<_Up, unsigned int> && is_unsigned_v<_Tp>);
 
+template <class _Tp, class _Generator, std::size_t _I, class = void>
+inline constexpr bool __is_well_formed = false;
+
+template <class _Tp, class _Generator, std::size_t _I>
+inline constexpr bool
+    __is_well_formed<_Tp,
+                     _Generator,
+                     _I,
+                     std::void_t<decltype(std::declval<_Generator>()(integral_constant<size_t, _I>()))>> =
+        __can_broadcast_v<_Tp, decltype(std::declval<_Generator>()(integral_constant<size_t, _I>()))>;
+
+template <class _Tp, class _Generator, std::size_t... _Is>
+constexpr bool __can_generate(index_sequence<_Is...>) {
+  return (true && ... && __is_well_formed<_Tp, _Generator, _Is>);
+}
+
 } // namespace parallelism_v2
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H

libcxx/include/experimental/__simd/vec_ext.h

struct __simd_operations<_Tp, simd_abi::__vec_ext<_Np>> {
 
   static _SimdStorage __broadcast(_Tp __v) noexcept {
     _SimdStorage __result;
     for (int __i = 0; __i < _Np; ++__i) {
       __result.__set(__i, __v);
     }
     return __result;
   }
+
+  template <class _Generator, size_t... _Is>
+  static _SimdStorage __generate_init(_Generator&& __g, std::index_sequence<_Is...>) {
+    return _SimdStorage{{__g(std::integral_constant<size_t, _Is>())...}};
+  }
+
+  template <class _Generator>
+  static _SimdStorage __generate(_Generator&& __g) noexcept {
+    return __generate_init(std::forward<_Generator>(__g), std::make_index_sequence<_Np>());
+  }
 };
 
 template <class _Tp, int _Np>
 struct __mask_operations<_Tp, simd_abi::__vec_ext<_Np>> {
   using _MaskStorage = __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>;
 
   static _MaskStorage __broadcast(bool __v) noexcept {
     _MaskStorage __result;

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.class]
+// template<class G> explicit simd(G&& gen) noexcept;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <class T, std::size_t>
+struct CheckGenerateSimdCtor {
+  template <class SimdAbi>
+  void operator()() {
+    ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
+    constexpr size_t array_size = origin_simd.size();
+    std::array<T, array_size> expected_value;
+    for (size_t i = 0; i < array_size; ++i)
+      expected_value[i] = static_cast<T>(i);
+    assert_simd_values_equal<array_size>(origin_simd, expected_value);
+  }
+};
+
+int main(int, char**) {
+  test_all_simd_abi<CheckGenerateSimdCtor>();
+  return 0;
+}