Fix #2026 - Prevent logical<wide> to be constructed form non-bool sin…

…gle scalars

include/eve/arch/cpu/logical_wide.hpp

@@ -142,13 +142,13 @@ namespace eve
     {
     }
 
-    //! Constructs a eve::logical by splatting a scalar value in all lanes
-    template<scalar_value S>
-    EVE_FORCEINLINE explicit logical(S v) noexcept
+    //! Construct from a scalar logical
+    template<scalar_value U>
+    EVE_FORCEINLINE explicit logical(logical<U> v) noexcept
                   : storage_base(detail::make(eve::as<logical>{}, v)) {}
 
     //! Construct from a `bool`
-    EVE_FORCEINLINE explicit logical(bool v) noexcept
+    EVE_FORCEINLINE explicit logical(std::same_as<bool> auto v) noexcept
                   : storage_base(detail::make(eve::as<logical>{}, v)) {}
 
     //! Constructs a eve::logical from a sequence of scalar values of proper size

include/eve/arch/cpu/wide.hpp

@@ -194,10 +194,14 @@ namespace eve
       storage_base::storage() = [&]<std::size_t... I>(std::index_sequence<I...>)
         {
           constexpr auto K = sizeof...(Ss);
-          return kumi::map([]<typename W>(auto const& n, W const&) { return W{n}; },
-                                 kumi::make_tuple(v0, vs..., kumi::element_t<K+I,Type>{}...),
-                                 *this
-                                );
+          return kumi::map([]<typename N, typename W>(N const& n, W const&)
+                            {
+                              if constexpr(scalar_value<N>) return W( typename W::value_type(n) );
+                              else                          return W(n);
+                            }
+                          , kumi::make_tuple(v0, vs..., kumi::element_t<K+I,Type>{}...)
+                          , *this
+                          );
         }(std::make_index_sequence<kumi::size_v<Type> - (1+sizeof...(Ss))>{});
     }
 

include/eve/detail/function/fill.hpp

@@ -28,7 +28,8 @@ namespace eve::detail
     }
     else
     {
-      return Pack( g(0,1) );
+      if constexpr(logical_value<Pack>) return Pack( static_cast<bool>(g(0,1)) );
+      else                              return Pack( g(0,1) );
     }
   }
 }

include/eve/detail/shuffle_v2/simd/common/shuffle_v2_driver.hpp

@@ -96,7 +96,7 @@ shuffle_v2_common_l0_l1(pattern_t<I...>, fixed<G>, kumi::tuple<T, Ts...> xs)
   {
     using N1 = eve::fixed<pattern_t<I...>::size() * G>;
     using T1 = typename T::template rescale<N1>;
-    return kumi::tuple {T1 {0}, eve::index<1>};
+    return kumi::tuple {T1{ typename T1::value_type(0) }, eve::index<1>};
   }
   else return kumi::tuple {no_matching_shuffle_t {}, eve::index<-1>};
 }

include/eve/module/core/detail/generic/find_optimized_shuffle_pattern.hpp

@@ -75,7 +75,7 @@ struct zero_swizzle
     {
       return w_t(kumi::map([]<typename T>(T) { return as_wide_t<T, Cardinal> {0}; }, w));
     }
-    else { return w_t {0}; }
+    else { return w_t{ typename w_t::value_type{0} }; }
   }
 };
 

include/eve/module/core/regular/impl/slide_left.hpp

@@ -19,16 +19,17 @@ template<simd_value Wide, std::ptrdiff_t Shift>
 EVE_FORCEINLINE auto
 slide_left_(EVE_SUPPORTS(cpu_), Wide v, index_t<Shift>) noexcept requires(Shift <= Wide::size())
 {
+  using type = typename Wide::value_type;
   if constexpr( Shift == 0 ) return v;
-  else if constexpr( Shift == Wide::size() ) return Wide {0};
+  else if constexpr( Shift == Wide::size() ) return Wide{type{0}};
   else if constexpr( has_aggregated_abi_v<Wide> )
   {
     if constexpr( Shift >= Wide::size() / 2 )
     {
       // We slide so much the upper part is full of zero
       // and the lower part is a slide of the former higher part
       auto h = v.slice(upper_);
-      return Wide {slide_left(h, index<Shift - Wide::size() / 2>), decltype(h) {0}};
+      return Wide {slide_left(h, index<Shift - Wide::size() / 2>), decltype(h) {type{0}}};
     }
     else
     {

include/eve/module/core/regular/impl/slide_right.hpp

@@ -23,16 +23,17 @@ template<simd_value Wide, std::ptrdiff_t Shift>
 EVE_FORCEINLINE auto
 slide_right_(EVE_SUPPORTS(cpu_), Wide v, index_t<Shift>) noexcept requires(Shift <= Wide::size())
 {
+  using type = typename Wide::value_type;
   if constexpr( Shift == 0 ) return v;
-  else if constexpr( Shift == Wide::size() ) return Wide {0};
+  else if constexpr( Shift == Wide::size() ) return Wide {type{0}};
   else if constexpr( has_aggregated_abi_v<Wide> )
   {
     if constexpr( Shift >= Wide::size() / 2 )
     {
       // We slide so much the lower part is full of zero
       // and the upper part is a slide of the former higher part
       auto l = v.slice(lower_);
-      return Wide {decltype(l) {0}, slide_right(l, index<Shift - Wide::size() / 2>)};
+      return Wide {decltype(l) {type{0}}, slide_right(l, index<Shift - Wide::size() / 2>)};
     }
     else
     {

include/eve/traits/overload/default_behaviors.hpp

@@ -385,11 +385,12 @@ namespace eve
                                                          , as_wide_as<type, T>
                                                          >::type;
 
-        auto that = out_t{constant_value};
+        using e_t = eve::element_type_t<out_t>;
+        out_t that(static_cast<e_t>(constant_value));
 
         // Apply a mask if any and replace missing values with 0 if no alternative is provided
         if constexpr(match_option<condition_key, O, ignore_none_>) return that;
-        else return detail::mask_op(opts[condition_key], detail::return_2nd, out_t{0}, that);
+        else return detail::mask_op(opts[condition_key], detail::return_2nd, out_t{e_t(0)}, that);
       }
     }
   };

test/unit/api/regular/wide.cpp

@@ -63,12 +63,9 @@ TTS_CASE_TPL( "Check eve::wide splat constructor", eve::test::simd::all_types)
 
   TTS_EQUAL(eve::logical<T>(l_t{true}) , all_true );
   TTS_EQUAL(eve::logical<T>(true)      , all_true );
-  TTS_EQUAL(eve::logical<T>(42)        , all_true );
 
   TTS_EQUAL(eve::logical<T>(l_t{false}) , all_false );
   TTS_EQUAL(eve::logical<T>(false)      , all_false );
-  TTS_EQUAL(eve::logical<T>(0)          , all_false );
-
 
   // Test smaller size wide for non-garbage
   using v_t = typename T::value_type;

test/unit/memory/store/aligned.cpp

@@ -75,11 +75,12 @@ TTS_CASE_WITH( "Check store behavior with pointer of different alignment"
       if(::tts::arguments()[{"-v","--verbose"}])
         std::cout << "With alignment: " << A << std::endl;
 
-      eve::aligned_ptr<eve::element_type_t<D>, eve::fixed<A>> ptr{f};
+      using d_t = eve::element_type_t<D>;
+      eve::aligned_ptr<d_t, eve::fixed<A>> ptr{f};
       eve::store(d, ptr);
       TTS_EQUAL(D{f}, d);
-      eve::store(D{0}, ptr);
-      TTS_EQUAL(D{f}, D{0});
+      eve::store(D{d_t{0}}, ptr);
+      TTS_EQUAL(D{f}, D{d_t{0}});
       eve::store[eve::ignore_none](d, ptr);
       TTS_EQUAL(D{f}, d);
     }

test/unit/module/core/constant/constants.cpp

@@ -16,8 +16,8 @@ TTS_CASE_TPL("Check basic constants behavior", eve::test::simd::all_types)
 {
   using eve::as;
   TTS_IEEE_EQUAL(eve::allbits(as<T>()), eve::bit_not(T(0)));
-  TTS_EQUAL(eve::true_(as<T>()), eve::as_logical_t<T>(1));
-  TTS_EQUAL(eve::false_(as<T>()), eve::as_logical_t<T>(0));
+  TTS_EQUAL(eve::true_(as<T>()), eve::as_logical_t<T>(true));
+  TTS_EQUAL(eve::false_(as<T>()), eve::as_logical_t<T>(false));
   TTS_EQUAL(eve::one(as<T>()), T(1));
   TTS_EQUAL(eve::mone(as<T>()), T(-1));
   TTS_EQUAL(eve::zero(as<T>()), T(0));
@@ -98,8 +98,8 @@ TTS_CASE_TPL("Check basic masked constants behavior", eve::test::simd::all_types
   T p{[](auto i, auto){return i; }};
   auto test = [p](auto a){return eve::if_else(p > 1, a, eve::zero); };
   TTS_IEEE_EQUAL(eve::allbits[p > 1](as<T>()), test(eve::bit_not(T(0))));
-  TTS_EQUAL(eve::true_[p > 1](as<T>()), test(eve::as_logical_t<T>(1)));
-  TTS_EQUAL(eve::false_[p > 1](as<T>()), test(eve::as_logical_t<T>(0)));
+  TTS_EQUAL(eve::true_[p > 1](as<T>()), test(eve::as_logical_t<T>(true)));
+  TTS_EQUAL(eve::false_[p > 1](as<T>()), test(eve::as_logical_t<T>(false)));
   TTS_EQUAL(eve::one[p > 1](as<T>()), test(T(1)));
   TTS_EQUAL(eve::mone[p > 1](as<T>()), test(T(-1)));
   TTS_EQUAL(eve::zero[p > 1](as<T>()), test(T(0)));