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

[Joy12138]

Update status paper and test

[Joy12138]

Add newline at end of file

[Joy12138]

Fix CI

[Joy12138]

Fix CI

[philnik]

libcxx/include/experimental/__simd/simd.h

46

libcxx/include/experimental/__simd/utility.h

61–66

Isn't this just is_constructible<__To, __From>?

61–66

libcxx/include/experimental/__simd/vec_ext.h

67

[Joy12138]

Fix some comments

[Joy12138]

libcxx/include/experimental/__simd/utility.h

61–66

I'm not sure if the current implementation is the same as is_constructible.
I am also not sure if either of them can meet the requirements of the document: "every possible value of From can be represented with type To".
Do you have any suggestion?

[philnik]

libcxx/include/experimental/__simd/utility.h

61–66

I think we have to do something a bit more weird for that. I think we basically have to check that they are integral and that sizeof(From) >= sizeof(To) && is_signed_v<From> == is_signed_v<To>. I'm not sure about floating point types, but there we probably want to do the same % bfloat16 (but that's not relevant for now anyways).

Also, we probably want to make these variable templates instead of structs. Didn't notice that before.

72

I'm pretty sure that unsigned int is indeed unsigned.

[Joy12138]

Fix some comments

[Joy12138]

libcxx/include/experimental/__simd/utility.h

61–66

According to your description, I think what you want is to check for non narrowing conversions. I have learned that brace initialization might ensure non narrowing conversions. What do you think about current implementation?

72

I'm not sure, but have you confused _Up and _Tp?

[philnik]

libcxx/include/experimental/__simd/utility.h

61–66

Good thought! This should indeed do the right thing. You're only missing inlines to avoid ODR violations.

72

Oops. Yes, I missed that there is _Tp and _Up. Just ignore the comment.

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

62–78

Or am I missing something?

libcxx/test/std/experimental/simd/simd.class/simd_ctor_broadcast.verify.cpp

30 ↗

(On Diff #548464)

These tests should be SFINAE checks instead, since the function shall not participate in overload resolution. This construct is not always ill-formed.

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

69

76

[philnik]

Do you know how much is still missing that the old implementation had?

[Joy12138]

Fix some comments

[Joy12138]

In D156225#4573755, @philnik wrote:

Do you know how much is still missing that the old implementation had?

Compare with llvm-project branch main, following implementations are still missing:

• Default constructor of class simd (simd() = default;)
• Implicit type conversion constructor of class simd (simd(const simd<_Up, simd_abi::fixed_size<size()>>&))
• Generator constructor of class simd (simd(_Generator&& __g))
• Load constructor of class simd (simd(const _Up* __buffer, _Flags))
• Load and store of class simd (copy_from() and copy_to())
• Scalar access of class simd (operator [])
• Operators and functions of class __simd_reference

[Joy12138]

Fix CI

[Joy12138]

Add SFINAE tests

[Joy12138]

The CI errors appear to be related to the type __int128 and __int128 unsigned. I tried these types and it is not supported in GCC implementation (https://godbolt.org/z/EExodWKxE), too. Should we support them? Or where should they be excluded? @philnik

[philnik]

In D156225#4579302, @Joy12138 wrote:

The CI errors appear to be related to the type __int128 and __int128 unsigned. I tried these types and it is not supported in GCC implementation (https://godbolt.org/z/EExodWKxE), too. Should we support them? Or where should they be excluded? @philnik

I don't really see a reason not to support it. A simple test seems to suggest that __int128 works just fine with vector types: https://godbolt.org/z/W9v6T6c8d. So my suspicion is that there is a bug somewhere in your code. It could of course also be a compiler bug, which is supported by the fact that Clang is happy with the code while GCC isn't. Either way, I think we should investigate this.

[Joy12138]

Try to fix __int128

[Joy12138]

It seems is_integral not working correctly with int128 and unsigned int128. https://godbolt.org/z/c4E5T7zc9

I add specializations for __can_broadcast with int128 and unsigned int128. It may fix tests now. Is it OK? Or should we fix is_integral?

[philnik]

In D156225#4584167, @Joy12138 wrote:

It seems is_integral not working correctly with int128 and unsigned int128. https://godbolt.org/z/c4E5T7zc9

I add specializations for __can_broadcast with int128 and unsigned int128. It may fix tests now. Is it OK? Or should we fix is_integral?

is_integral is fine: https://godbolt.org/z/bdof3Krvo. It also looks like your change didn't actually fix the problem.

[Joy12138]

I attempted to debug the error in the CI. When _Tp is __int128 unsigned, in the __broadcast function within the vec_ext.h header, the value of __result.__get(0) printed just before the return statement is correct. However, after the return, in the broadcast constructor within the simd.h header, the higher 64 bits of the value printed as _Impl::__broadcast(static_cast<value_type>(__v)).__get(0) become garbled data. It seems that the value is being truncated upon return.

Strangely, this issue only reproduces in the current libcxx CI - GCC 12 / C++latest environment. I have been unable to reproduce this issue in any other environment.

Currently, I am unsure how to go about fixing this issue. Do you have any suggestions? @philnik

[Joy12138]

Remove incorrect fixes

[Joy12138]

Remove incorrect fixes

[Mordante]

In D156225#4620453, @Joy12138 wrote:

I attempted to debug the error in the CI. When _Tp is __int128 unsigned, in the __broadcast function within the vec_ext.h header, the value of __result.__get(0) printed just before the return statement is correct. However, after the return, in the broadcast constructor within the simd.h header, the higher 64 bits of the value printed as _Impl::__broadcast(static_cast<value_type>(__v)).__get(0) become garbled data. It seems that the value is being truncated upon return.

Strangely, this issue only reproduces in the current libcxx CI - GCC 12 / C++latest environment. I have been unable to reproduce this issue in any other environment.

Currently, I am unsure how to go about fixing this issue. Do you have any suggestions? @philnik

Our minimum supported GCC version recently changed to GCC-13. Can you rebase this patch? That will pick up GCC-13 in the CI.

[philnik]

I think we should try to rebase, as @Mordante suggested. If that doesn't help I'd just go for // XFAIL: gcc-13ing the tests for now. If the bug still exists in GCC 13 it would be great if you could try to get a small reproducer and file a bug against GCC.

[Joy12138]

Rebase

[Joy12138]

Rebase

[Joy12138]

Temporarily add // XFAIL: gcc-13

[Joy12138]

Rebase

[Joy12138]

Rebase

[Joy12138]

Rebase

[ldionne]

This broke the CI, see https://buildkite.com/llvm-project/libcxx-ci/builds/29619#018a8977-1827-49a1-a154-5d960fc5da5e. Can you please fix or revert?

[Joy12138]

In D156225#4644460, @ldionne wrote:

This broke the CI, see https://buildkite.com/llvm-project/libcxx-ci/builds/29619#018a8977-1827-49a1-a154-5d960fc5da5e. Can you please fix or revert?

Thank you very much for your reminder. I tried to fix this issue in revision https://reviews.llvm.org/D159509 and land this patch after CI passed.

libcxx/docs/Status/ParallelismProjects.csv

 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "simd type traits is_simd_flag_type", None, Yin Zhang, |In Progress|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "`simd type traits simd_size[_v] <https://reviews.llvm.org/D144363>`_", [parallel.simd.traits] is_abi_tag[_v], Yin Zhang, |Complete|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "`simd type traits memory_alignment <https://reviews.llvm.org/D153319>`_", [parallel.simd.aligned] simd aligned tags, Yin Zhang, |Complete|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "simd type traits rebind_simd", None, Yin Zhang, |In Progress|
 | `[parallel.simd.traits] <https://wg21.link/N4808>`_, "simd type traits resize_simd", None, Yin Zhang, |In Progress|
 | `[parallel.simd.whereexpr] <https://wg21.link/N4808>`_, "Where expression class templates", None, Yin Zhang, |In Progress|
 | `[parallel.simd.class] <https://wg21.link/N4808>`_, "`Class template simd declaration and alias <https://reviews.llvm.org/D144362>`_", [parallel.simd.abi], Yin Zhang, |Complete|
 | `[parallel.simd.class] <https://wg21.link/N4808>`_, "`simd<>::size() <https://reviews.llvm.org/D144363>`_", [parallel.simd.traits] simd_size[_v], Yin Zhang, |Complete|
+| `[parallel.simd.class] <https://wg21.link/N4808>`_, "`simd broadcast constructor <https://reviews.llvm.org/D156225>`_", None, Yin Zhang, |Complete|
 | `[parallel.simd.class] <https://wg21.link/N4808>`_, "Class template simd implementation", None, Yin Zhang, |In Progress|
 | `[parallel.simd.nonmembers] <https://wg21.link/N4808>`_, "simd non-member operations", None, Yin Zhang, |In Progress|
 | `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "`Class template simd_mask declaration and alias <https://reviews.llvm.org/D144362>`_", [parallel.simd.abi], Yin Zhang, |Complete|
 | `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "`simd_mask<>::size() <https://reviews.llvm.org/D144363>`_", [parallel.simd.class] simd<>::size(), Yin Zhang, |Complete|
+| `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "`simd_mask broadcast constructor <https://reviews.llvm.org/D156225>`_", None, Yin Zhang, |Complete|
 | `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "Class template simd_mask implementation", None, Yin Zhang, |In Progress|
 | `[parallel.simd.mask.nonmembers] <https://wg21.link/N4808>`_, "simd_mask non-member operations", None, Yin Zhang, |In Progress|

libcxx/include/experimental/__simd/scalar.h

 
 template <class _Tp>
 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 _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

 // -*- 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_SIMD_H
 #define _LIBCPP_EXPERIMENTAL___SIMD_SIMD_H
 
+#include <__type_traits/remove_cvref.h>
 #include <experimental/__simd/abi_tag.h>
 #include <experimental/__simd/declaration.h>
 #include <experimental/__simd/reference.h>
 #include <experimental/__simd/scalar.h>
 #include <experimental/__simd/traits.h>
 #include <experimental/__simd/vec_ext.h>
 
 #if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)

 
 public:
   using value_type = _Tp;
   using reference  = __simd_reference<_Tp, _Storage, value_type>;
   using mask_type  = simd_mask<_Tp, _Abi>;
   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))) {}
+
+  // 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/simd_mask.h

 
 public:
   using value_type = bool;
   using reference  = __simd_reference<_Tp, _Storage, value_type>;
   using simd_type  = simd<_Tp, _Abi>;
   using abi_type   = _Abi;
 
   static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return simd_type::size(); }
+
+  // broadcast constructor
+  _LIBCPP_HIDE_FROM_ABI explicit simd_mask(value_type __v) noexcept : __s_(_Impl::__broadcast(__v)) {}
+
+  // scalar access [simd.mask.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_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
 
 template <class _Tp, int _Np>
 using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
 
 } // namespace parallelism_v2
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_SIMD_MASK_H

libcxx/include/experimental/__simd/utility.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
 #define _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
 
 #include <__type_traits/is_arithmetic.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 <cstdint>
 #include <limits>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 inline namespace parallelism_v2 {
 template <class _Tp>
-constexpr bool __is_vectorizable_v =
+inline constexpr bool __is_vectorizable_v =
     is_arithmetic_v<_Tp> && !is_const_v<_Tp> && !is_volatile_v<_Tp> && !is_same_v<_Tp, bool>;
 
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI auto __choose_mask_type() {
   if constexpr (sizeof(_Tp) == 1) {
     return uint8_t{};
   } else if constexpr (sizeof(_Tp) == 2) {
     return uint16_t{};
else
     static_assert(sizeof(_Tp) == 0, "Unexpected size");
 }
 
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI auto constexpr __set_all_bits(bool __v) {
   return __v ? (numeric_limits<decltype(__choose_mask_type<_Tp>())>::max()) : 0;
 }
 
+template <class _From, class _To, class = void>
+inline constexpr bool __is_non_narrowing_convertible_v = false;
+
+template <class _From, class _To>
+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>);
+
 } // 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

 template <class _Tp, int _Np>
 struct __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>
     : __simd_storage<decltype(experimental::__choose_mask_type<_Tp>()), simd_abi::__vec_ext<_Np>> {};
 
 template <class _Tp, int _Np>
 struct __simd_operations<_Tp, simd_abi::__vec_ext<_Np>> {
   using _SimdStorage = __simd_storage<_Tp, simd_abi::__vec_ext<_Np>>;
   using _MaskStorage = __mask_storage<_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 _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;
+    auto __all_bits_v = experimental::__set_all_bits<_Tp>(__v);
+    for (int __i = 0; __i < _Np; ++__i) {
+      __result.__set(__i, __all_bits_v);
+    }
+    return __result;
+  }
 };
 
 } // namespace parallelism_v2
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
 #endif // _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.class]
+// template<class U> simd(U&& value) noexcept;
+
+// GCC returns __int128 unsigned with garbled data in higher 64 bits.
+// This is likely a bug in GCC implementation. Investigation needed.
+// XFAIL: gcc-13
+
+#include "../test_utils.h"
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <class T, class SimdAbi, std::size_t array_size>
+struct BroadCastHelper {
+  const std::array<T, array_size>& expected_value;
+
+  BroadCastHelper(const std::array<T, array_size>& value) : expected_value(value) {}
+
+  template <class U>
+  void operator()() const {
+    if constexpr (is_non_narrowing_convertible_v<U, T>) {
+      ex::simd<T, SimdAbi> simd_broadcast_from_vectorizable_type(static_cast<U>(3));
+      assert_simd_values_equal<array_size>(simd_broadcast_from_vectorizable_type, expected_value);
+    }
+  }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBroadcastCtorFromVectorizedType {
+  template <class SimdAbi>
+  void operator()() {
+    constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+    std::array<T, array_size> expected_value;
+    std::fill(expected_value.begin(), expected_value.end(), 3);
+
+    types::for_each(arithmetic_no_bool_types(), BroadCastHelper<T, SimdAbi, array_size>(expected_value));
+  }
+};
+
+template <class T>
+class implicit_type {
+  T val;
+
+public:
+  implicit_type(T v) : val(v) {}
+  operator T() const { return val; }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBroadcastCtor {
+  template <class SimdAbi>
+  void operator()() {
+    constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+    std::array<T, array_size> expected_value;
+    std::fill(expected_value.begin(), expected_value.end(), 3);
+
+    implicit_type<T> implicit_convert_to_3(3);
+    ex::simd<T, SimdAbi> simd_broadcast_from_implicit_type(std::move(implicit_convert_to_3));
+    assert_simd_values_equal<array_size>(simd_broadcast_from_implicit_type, expected_value);
+
+    ex::simd<T, SimdAbi> simd_broadcast_from_int(3);
+    assert_simd_values_equal<array_size>(simd_broadcast_from_int, expected_value);
+
+    if constexpr (std::is_unsigned_v<T>) {
+      ex::simd<T, SimdAbi> simd_broadcast_from_uint(3u);
+      assert_simd_values_equal<array_size>(simd_broadcast_from_uint, expected_value);
+    }
+  }
+};
+
+template <class T>
+class no_implicit_type {
+  T val;
+
+public:
+  no_implicit_type(T v) : val(v) {}
+};
+
+template <class U, class T, class SimdAbi = ex::simd_abi::compatible<T>, class = void>
+struct has_broadcast_ctor : std::false_type {};
+
+template <class U, class T, class SimdAbi>
+struct has_broadcast_ctor<U, T, SimdAbi, std::void_t<decltype(ex::simd<T, SimdAbi>(std::declval<U>()))>>
+    : std::true_type {};
+
+template <class T, class SimdAbi>
+struct CheckBroadcastCtorTraitsHelper {
+  template <class U>
+  void operator()() const {
+    if constexpr (std::is_same_v<U, int>)
+      static_assert(has_broadcast_ctor<U, T, SimdAbi>::value);
+    else if constexpr (std::is_same_v<U, unsigned int> && std::is_unsigned_v<T>)
+      static_assert(has_broadcast_ctor<U, T, SimdAbi>::value);
+    else if constexpr (is_non_narrowing_convertible_v<U, T>)
+      static_assert(has_broadcast_ctor<U, T, SimdAbi>::value);
+    else
+      static_assert(!has_broadcast_ctor<U, T, SimdAbi>::value);
+  }
+};
+
+template <class T, std::size_t>
+struct CheckBroadcastCtorTraits {
+  template <class SimdAbi>
+  void operator()() {
+    types::for_each(arithmetic_no_bool_types(), CheckBroadcastCtorTraitsHelper<T, SimdAbi>());
+
+    static_assert(!has_broadcast_ctor<no_implicit_type<T>, T, SimdAbi>::value);
+    static_assert(has_broadcast_ctor<implicit_type<T>, T, SimdAbi>::value);
+  }
+};
+
+int main(int, char**) {
+  test_all_simd_abi<CheckSimdBroadcastCtorFromVectorizedType>();
+  test_all_simd_abi<CheckSimdBroadcastCtor>();
+  test_all_simd_abi<CheckBroadcastCtorTraits>();
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.mask.class]
+// explicit simd_mask(value_type) noexcept;
+
+// GCC returns __int128 unsigned with garbled data in higher 64 bits.
+// This is likely a bug in GCC implementation. Investigation needed.
+// XFAIL: gcc-13
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <class T, std::size_t>
+struct CheckMaskBroadcastCtor {
+  template <class SimdAbi>
+  void operator()() {
+    constexpr size_t array_size = ex::simd_size_v<T, SimdAbi>;
+    const ex::simd_mask<T, SimdAbi> mask_ctor_from_broadcast(false);
+    const std::array<bool, array_size> expected_value{};
+    assert_simd_mask_values_equal(mask_ctor_from_broadcast, expected_value);
+  }
+};
+
+int main(int, char**) {
+  test_all_simd_abi<CheckMaskBroadcastCtor>();
+  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 <algorithm>
+#include <array>
+#include <cassert>
+#include <type_traits>
 #include <utility>
 #include <experimental/simd>
 #include "type_algorithms.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 constexpr std::size_t max_simd_size = 32;
 

 
 constexpr size_t bit_ceil(size_t val) {
   size_t pow = 1;
   while (pow < val)
     pow <<= 1;
   return pow;
 }
 
+template <class From, class To, class = void>
+inline constexpr bool is_non_narrowing_convertible_v = false;
+
+template <class From, class To>
+inline constexpr bool is_non_narrowing_convertible_v<From, To, std::void_t<decltype(To{std::declval<From>()})>> = true;
+
+template <std::size_t ArraySize, class SimdAbi, class T, class U = T>
+void assert_simd_values_equal(const ex::simd<T, SimdAbi>& origin_simd, const std::array<U, ArraySize>& expected_value) {
+  for (std::size_t i = 0; i < origin_simd.size(); ++i)
+    assert(origin_simd[i] == static_cast<T>(expected_value[i]));
+}
+
+template <std::size_t ArraySize, class T, class SimdAbi>
+void assert_simd_mask_values_equal(const ex::simd_mask<T, SimdAbi>& origin_mask,
+                                   const std::array<bool, ArraySize>& expected_value) {
+  for (std::size_t i = 0; i < origin_mask.size(); ++i)
+    assert(origin_mask[i] == expected_value[i]);
+}
+
 #endif // TEST_UTIL_H