Implement P4012R1 and revert P3844R2 (consteval broadcast)

Keep the old behavior behind VIR_CONSTEVAL_BROADCAST but default to the
C++26 behavior. Rewrite uses of the consteval broadcast to use std::cw
or cast to value_type instead.

Adjust the deploy.sh script to also deploy tests.

ChangeLog:

	* README.md: Update P4012R1 status to done.
	* codegen/select.c++:
	* constexpr_tests.cpp:
	* deploy.sh:
	* include/bits/simd_complex.h:
	* include/bits/simd_details.h:
	* include/bits/simd_mask.h:
	* include/bits/simd_math.h:
	* include/bits/simd_vec.h:
	* lib/hypot2.cpp:
	* lib/hypot3.cpp:
	* lib/support.h:
	* math-traits_tests.cpp:
	* tests/arithmetic.cpp:
	* tests/complex-math.cpp:
	* tests/mask.cpp:
	* tests/math.cpp:
	* tests/simd_alg.cpp:
	* tests/unittest_pch.h:

Author: mattkretz

README.md

@@ -29,7 +29,7 @@
 | [P3983R0](https://wg21.link/P3983R0) simd object representation                                | 🔴 open (still in design phase) |
 | [P3985R0](https://wg21.link/P3985R0) Concepts for std::simd                                    | 🔴 open (still in design phase) |
 | [P3844R4](https://wg21.link/P3844R4) Reword [simd.math] for consteval conversions              | ✅ done         |
-| [P4012R1](https://wg21.link/P4012R1) value-preserving consteval broadcast to simd::vec         | 🔴 open |
+| [P4012R1](https://wg21.link/P4012R1) value-preserving consteval broadcast to simd::vec         | ✅ done         |
 | [P4042R0](https://wg21.link/P4042R0) Fix LWG4543: incorrect cast between `simd::vec` and `simd::mask` [...] | ✅ done |
 
 | Issue | Status |

codegen/select.c++

@@ -50,7 +50,7 @@ V0 test0b(V0::mask_type a)
 { return simd::select(a, char(1), char(0)); }
 
 V0 test0c(V0::mask_type a)
-{ return simd::select(a, V0(1), V0()); }
+{ return simd::select(a, V0(char(1)), V0()); }
 
 V0 test0d(V0 a, V0 b, V0 c)
 { return simd::select(a == a, b, c); }
@@ -92,7 +92,7 @@ V1 test1b(V1::mask_type a)
 { return simd::select(a, T1(1), T1()); }
 
 V1 test1c(V1::mask_type a)
-{ return simd::select(a, V1(1), V1()); }
+{ return simd::select(a, V1(T1(1)), V1()); }
 
 /* codegen
 ^"test2a(
@@ -123,7 +123,7 @@ V2 test2b(V2::mask_type a)
 { return simd::select(a, short(1), short()); }
 
 V2 test2c(V2::mask_type a)
-{ return simd::select(a, V2(1), V2()); }
+{ return simd::select(a, V2(short(1)), V2()); }
 
 V2 test2d(V2 a, V2 b, V2 c)
 { return simd::select(a == a, b, c); }

constexpr_tests.cpp

@@ -49,12 +49,18 @@ namespace LWG4420
     simd::vec<float, 4> vh2f_b = float16_t();
 
     simd::vec<float16_t, 4> vf2h = {f4, simd::flag_convert};
+#if VIR_CONSTEVAL_BROADCAST
     simd::vec<float16_t, 4> vf2h_b{float()};
+#endif
 
     vh2f = vf2h;
     vf2h = static_cast<decltype(vf2h)>(vh2f);
 
+#if VIR_CONSTEVAL_BROADCAST
     return all_of(vh2f == vh2f_b) && all_of(vf2h == vf2h_b);
+#else
+    return all_of(vh2f == vh2f_b);
+#endif
   }());
 }
 #endif
@@ -141,7 +147,11 @@ namespace test02
   // ensure 'true ? int : vec<float>' doesn't work
   template <typename T>
     concept has_type_member = requires { typename T::type; };
+#if VIR_CONSTEVAL_BROADCAST
   static_assert(has_type_member<common_type<int, simd::vec<float>>>);
+#else
+  static_assert(!has_type_member<common_type<int, simd::vec<float>>>);
+#endif
 
   constexpr simd::vec<complex<double>>::mask_type k = {};
 }
@@ -176,7 +186,11 @@ static_assert( std::convertible_to<Ic<1>, simd::vec<float>>);
 static_assert(!std::convertible_to<Ic<1.1>, simd::vec<float>>);
 static_assert(!std::convertible_to<simd::vec<int, 4>, simd::vec<float, 4>>);
 static_assert(!std::convertible_to<simd::vec<float, 4>, simd::vec<int, 4>>);
+#if VIR_CONSTEVAL_BROADCAST
 static_assert( std::convertible_to<int, simd::vec<float>>);
+#else
+static_assert(!std::convertible_to<int, simd::vec<float>>);
+#endif
 static_assert( std::convertible_to<simd::vec<int, 4>, simd::vec<double, 4>>);
 
 template <typename V>

deploy.sh

@@ -10,10 +10,11 @@ set -e
 
 # Source and destination directories
 SRC_DIR="include/bits"
-DEST_DIR="/home/mkretz/src/gcc-simd/libstdc++-v3/include/bits"
+DEST_DIR="/home/mkretz/src/gcc-master/libstdc++-v3/include/bits"
+TEST_DIR="/home/mkretz/src/gcc-master/libstdc++-v3/testsuite/std/simd"
 
-# Create destination directory if it doesn't exist
-mkdir -p "$DEST_DIR"
+if ! test -d "$DEST_DIR"; then echo "$DEST_DIR is missing"; fi
+if ! test -d "$TEST_DIR"; then echo "$TEST_DIR is missing"; fi
 
 filter() {
   invert=0
@@ -146,22 +147,34 @@ EOF
 grep '^$' -A100000
 }
 
+all_filters() {
+  filter VIR_EXTENSIONS \
+    | filter VIR_PATCH_PERMUTE_DYNAMIC \
+    | filter VIR_PATCH_MATH \
+    | filter VIR_PATCH_IMPROVE_CX \
+    | filter VIR_PATCH_MISSED_OPT \
+    | filter VIR_PATCH_TEST_STORES \
+    | filter VIR_ASSERT_SANITY \
+    | filter VIR_CONSTEVAL_BROADCAST \
+    | fix_copyright
+}
+
 # Process each .h file in the source directory
 for file in "$SRC_DIR"/*.h; do
   if [ -f "$file" ]; then
     filename=$(basename "$file")
     echo "Processing $filename..."
-
-    # Use awk to handle VIR_EXTENSIONS conditional blocks
-    cat "$file" | filter VIR_EXTENSIONS \
-      | filter VIR_PATCH_PERMUTE_DYNAMIC \
-      | filter VIR_PATCH_MATH \
-      | filter VIR_PATCH_IMPROVE_CX \
-      | filter VIR_PATCH_MISSED_OPT \
-      | filter VIR_PATCH_TEST_STORES \
-      | filter VIR_ASSERT_SANITY \
-      | fix_copyright > "$DEST_DIR/$filename"
+    cat "$file" | all_filters > "$DEST_DIR/$filename"
   fi
 done
 
-echo "Deployment complete. Processed files copied to $DEST_DIR/"
+cat math-traits_tests.cpp | all_filters > "$TEST_DIR/traits_math.cc"
+cat constexpr_tests.cpp | all_filters > "$TEST_DIR/traits_common.cc"
+cat generic-traits_tests.cpp | all_filters > "$TEST_DIR/traits_impl.cc"
+for file in tests/*.cpp; do
+  filename=$(basename "$file")
+  echo "Processing $filename..."
+  cat "$file" | all_filters > "$TEST_DIR/${filename%.cpp}.cc"
+done
+
+echo "Deployment complete. Processed files copied to $DEST_DIR/ and $TEST_DIR/"

include/bits/simd_complex.h

@@ -1102,6 +1102,19 @@ namespace simd
       // TODO: conversion extensions
 
       // [simd.ctor] broadcast constructor ------------------------------------
+#if !VIR_CONSTEVAL_BROADCAST
+      template <__broadcast_constructible<value_type> _Up>
+	[[__gnu__::__always_inline__]]
+	constexpr
+	basic_vec(_Up&& __x) noexcept
+	  : _M_data([&](int __i) {
+	      if constexpr (__complex_like<_Up>)
+		return (__i & 1) == 0 ? __x.real() : __x.imag();
+	      else
+		return (__i & 1) == 0 ? __x : _T0();
+	    })
+	{}
+#else
       template <__explicitly_convertible_to<value_type> _Up>
 	[[__gnu__::__always_inline__]]
 	constexpr explicit(!__broadcast_constructible<_Up, value_type>)
@@ -1119,6 +1132,7 @@ namespace simd
 	basic_vec(const _Up& __x)
 	: basic_vec(__value_preserving_cast<value_type>(__x))
 	{}
+#endif
 
       // [simd.ctor] conversion constructor -----------------------------------
       template <__complex_like _Up, typename _UAbi>
@@ -2266,6 +2280,22 @@ namespace simd
       // TODO: conversion extensions
 
       // [simd.ctor] broadcast constructor ------------------------------------
+#if !VIR_CONSTEVAL_BROADCAST
+      template <__broadcast_constructible<value_type> _Up>
+	requires __complex_like<_Up>
+	[[__gnu__::__always_inline__]]
+	constexpr
+	basic_vec(_Up&& __x) noexcept
+	  : _M_real(__x.real()), _M_imag(__x.imag())
+	{}
+
+      template <__broadcast_constructible<value_type> _Up>
+	[[__gnu__::__always_inline__]]
+	constexpr
+	basic_vec(_Up&& __x) noexcept
+	  : _M_real(__x), _M_imag()
+	{}
+#else
       template <__explicitly_convertible_to<value_type> _Up>
 	requires __complex_like<_Up>
 	[[__gnu__::__always_inline__]]
@@ -2286,6 +2316,7 @@ namespace simd
 	basic_vec(const _Up& __x)
 	: _M_real(__x), _M_imag()
 	{}
+#endif
 
       // [simd.ctor] conversion constructor -----------------------------------
       template <__complex_like _Up, typename _UAbi>

include/bits/simd_details.h

@@ -1583,6 +1583,7 @@ namespace simd
       return static_cast<_To>(__x);
     }
 
+#if VIR_CONSTEVAL_BROADCAST
   template <typename _From, typename _To>
     concept __simd_vec_bcast_consteval
       = __explicitly_convertible_to<_From, _To>
@@ -1592,6 +1593,7 @@ namespace simd
 		|| (is_same_v<remove_cvref_t<_From>, int> && is_integral_v<_To>)
 		|| (is_same_v<remove_cvref_t<_From>, unsigned> && unsigned_integral<_To>));
 
+#endif
   /** @internal
    * std::pair is not trivially copyable, this one is
    */

include/bits/simd_mask.h

@@ -915,11 +915,12 @@ namespace simd
 		using _Ip = typename _VecType::value_type;
 		_VecType __v0 = _Ip(__val);
 		constexpr int __bits_per_element = sizeof(_Ip) * __CHAR_BIT__;
-		constexpr _VecType __pow2 = _VecType(1) << (__iota<_VecType> % __bits_per_element);
+		constexpr _VecType __pow2 = _VecType(cw<1>)
+					      << (__iota<_VecType> % cw<__bits_per_element>);
 		if constexpr (_S_size < __bits_per_element)
-		  return ((__v0 & __pow2) > 0)._M_concat_data();
+		  return ((__v0 & __pow2) > cw<0>)._M_concat_data();
 		else if constexpr (_S_size == __bits_per_element)
-		  return ((__v0 & __pow2) != 0)._M_concat_data();
+		  return ((__v0 & __pow2) != cw<0>)._M_concat_data();
 		else
 		  {
 		    static_assert(_Bytes == 1);
@@ -936,7 +937,7 @@ namespace simd
 			};
 			__v1 *= 0x0101'0101'0101'0101ull;
 			__v0 = __builtin_bit_cast(_VecType, __v1);
-			return ((__v0 & __pow2) != 0)._M_data;
+			return ((__v0 & __pow2) != cw<0>)._M_data;
 		      }
 		    else
 		      {
@@ -945,7 +946,7 @@ namespace simd
 			__v0 = _VecType::_S_static_permute(__v1, [](int __i) {
 				 return __i / __CHAR_BIT__;
 			       });
-			return ((__v0 & __pow2) != 0)._M_data;
+			return ((__v0 & __pow2) != cw<0>)._M_data;
 		      }
 		  }
 	      }
@@ -1041,7 +1042,7 @@ namespace simd
 	  else
 	    {
 	      using _UV = basic_vec<_Up, _UAbi>;
-	      return __select_impl(static_cast<_UV::mask_type>(*this), _UV(1), _UV(0));
+	      return __select_impl(static_cast<_UV::mask_type>(*this), _Up(1), _UV());
 	    }
 	}
 
@@ -1138,7 +1139,7 @@ namespace simd
 	      constexpr int __n = _IV::size();
 	      if constexpr (_Bytes * __CHAR_BIT__ >= __n) // '1 << __iota' cannot overflow
 		{ // reduce(select(k, powers_of_2, 0))
-		  constexpr _IV __pow2 = _IV(1) << __iota<_IV>;
+		  constexpr _IV __pow2 = _IV(cw<1>) << __iota<_IV>;
 		  return _Ur(_U0(__select_impl(__k, __pow2, _IV())
 				   ._M_reduce(bit_or<>()))) << _Offset;
 		}
@@ -1151,7 +1152,7 @@ namespace simd
 		}
 	      else
 		{ // limit powers_of_2 to 1, 2, 4, ..., 128
-		  constexpr _IV __pow2 = _IV(1) << (__iota<_IV> % _IV(__CHAR_BIT__));
+		  constexpr _IV __pow2 = _IV(cw<1>) << (__iota<_IV> % _IV(cw<__CHAR_BIT__>));
 		  _IV __x = __select_impl(__k, __pow2, _IV());
 		  // partial reductions of 8 neighboring elements
 		  __x |= _IV::_S_static_permute(__x, _SwapNeighbors<4>());

include/bits/simd_math.h

@@ -919,7 +919,7 @@ namespace simd
     __lerp(_Vp __a, _Vp __b, _Vp __t) noexcept
     {
       constexpr _Vp __zero = {};
-      constexpr _Vp __one(1);
+      constexpr _Vp __one(cw<1>);
       using _Mp = typename _Vp::mask_type;
 
       // TODO: benchmark which method of computing the mask is better

include/bits/simd_vec.h

@@ -318,7 +318,7 @@ namespace simd
 	    if constexpr (_S_is_partial)
 	      if (__do_sanitize)
 		return __select_impl(mask_type::_S_init(mask_type::_S_implicit_mask),
-				     *this, 0)._M_data;
+				     *this, __canon_value_type())._M_data;
 	    return _M_data;
 	  }
 #else
@@ -1169,6 +1169,14 @@ namespace simd
        *
        * @note The constructor is implicit if the conversion (if any) is value-preserving.
        */
+#if !VIR_CONSTEVAL_BROADCAST
+      template <__broadcast_constructible<value_type> _Up>
+	[[__gnu__::__always_inline__]]
+	constexpr
+	basic_vec(_Up&& __x) noexcept
+	  : _M_data(_DataType() == _DataType() ? static_cast<value_type>(__x) : value_type())
+	{}
+#else
       template <__explicitly_convertible_to<value_type> _Up>
 	[[__gnu__::__always_inline__]]
 	constexpr explicit(!__broadcast_constructible<_Up, value_type>)
@@ -1182,6 +1190,7 @@ namespace simd
 	: _M_data(_DataType() == _DataType()
 		    ? __value_preserving_cast<value_type>(__x) : value_type())
 	{}
+#endif
 
       // [simd.ctor] conversion constructor -----------------------------------
       template <typename _Up, typename _UAbi, _TargetTraits _Traits = {}>
@@ -2257,6 +2266,14 @@ namespace simd
       { return _M_concat_data(); }
 
       // [simd.ctor] broadcast constructor ------------------------------------
+#if !VIR_CONSTEVAL_BROADCAST
+      template <__broadcast_constructible<value_type> _Up>
+	[[__gnu__::__always_inline__]]
+	constexpr
+	basic_vec(_Up&& __x) noexcept
+	  : _M_data0(static_cast<value_type>(__x)), _M_data1(static_cast<value_type>(__x))
+	{}
+#else
       template <__explicitly_convertible_to<value_type> _Up>
 	[[__gnu__::__always_inline__]]
 	constexpr explicit(!__broadcast_constructible<_Up, value_type>)
@@ -2270,6 +2287,7 @@ namespace simd
 	: _M_data0(__value_preserving_cast<value_type>(__x)),
 	  _M_data1(__value_preserving_cast<value_type>(__x))
 	{}
+#endif
 
       // [simd.ctor] conversion constructor -----------------------------------
       template <typename _Up, typename _UAbi>

lib/hypot2.cpp

@@ -75,8 +75,8 @@ namespace std::simd
       // NaN inputs to min/max are UB (requires totally_ordered), replace inputs where a NaN output
       // is needed with precise 3²+4²=5².
       const M nan = isunordered(x, y);
-      const V absx = select(nan, V(3), fabs(x)); // no error
-      const V absy = select(nan, V(4), fabs(y)); // no error
+      const V absx = select(nan, T(3), fabs(x)); // no error
+      const V absy = select(nan, T(4), fabs(y)); // no error
       V hi = max(absx, absy); // no error
       V lo = min(absx, absy); // no error
       const auto huge_diff = is_large_diff(hi, lo);
@@ -88,11 +88,11 @@ namespace std::simd
           const V scale_back = rescale_factors(hi, lo);
           return scale_back * sqrt((lo * lo)._M_assoc_barrier() + hi * hi);
         }
-      else if (all_of(isnormal(x) || x == 0) && all_of(isnormal(y) || y == 0))
+      else if (all_of(isnormal(x) || x == T(0)) && all_of(isnormal(y) || y == T(0)))
 	{ // more likely and cheaper than the branch below
-	  const auto k0 = lo == 0;
+	  const auto k0 = lo == T(0);
 	  const auto h0 = hi;
-	  hi = select(hi == 0, V(1), hi);
+	  hi = select(hi == T(0), T(1), hi);
 	  const V scale_back = rescale_factors(hi, lo);
 	  const V r = scale_back * sqrt((lo * lo)._M_assoc_barrier() + hi * hi);
 	  return select(k0, h0, r);
@@ -104,7 +104,7 @@ namespace std::simd
           // slower path to support subnormals
           // if hi is subnormal, avoid scaling by inf & final mul by 0
           // (which yields NaN) by using min()
-          constexpr V subnorm_scale = 1 / norm_min_v<V>;
+	  constexpr V subnorm_scale = T(1) / norm_min_v<V>;
           // invert exponent w/o error and w/o using the slow divider
           // unit: xor inverts the exponent but off by 1. Multiplication
           // with .5 adjusts for the discrepancy.
@@ -131,7 +131,7 @@ namespace std::simd
           // ISA has FMAs (because h1² + lo is an FMA, but the
           // intermediate
           // h1² must be kept)
-	  return select(lo == 0 || nan || inf, fixup, r);
+	  return select(lo == T(0) || nan || inf, fixup, r);
         }
     }