Fix -Wshorten-64-to-32 warnings

serge-sans-paille · serge-sans-paille · commit 9c25f2f43938 · 2025-03-25T11:31:25.000Z
diff --git a/include/xsimd/arch/generic/xsimd_generic_logical.hpp b/include/xsimd/arch/generic/xsimd_generic_logical.hpp
@@ -49,7 +49,7 @@ namespace xsimd
                 // popcount instruction depending on the arch...
                 XSIMD_IF_CONSTEXPR(batch_bool<T, A>::size <= 32)
                 {
-                    uint32_t m32 = m;
+                    uint32_t m32 = static_cast<uint32_t>(m);
                     // https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
                     m32 = m32 - ((m32 >> 1) & 0x55555555); // reuse input as temporary
                     m32 = (m32 & 0x33333333) + ((m32 >> 2) & 0x33333333); // temp
diff --git a/include/xsimd/arch/xsimd_sse2.hpp b/include/xsimd/arch/xsimd_sse2.hpp
@@ -1021,7 +1021,7 @@ namespace xsimd
          */
         namespace detail
         {
-            XSIMD_INLINE int mask_lut(int mask)
+            XSIMD_INLINE int mask_lut(uint64_t mask)
             {
                 // clang-format off
                 static const int mask_lut[256] = {
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -48,6 +48,9 @@ set(TARGET_ARCH "native" CACHE STRING "Target architecture arguments")
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Intel")
     if (NOT WIN32 AND NOT ANDROID)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wunused-parameter -Wextra -Wreorder")
+        if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+          set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshorten-64-to-32")
+      endif()
         # Users may override the c++ standard:
         if(NOT DEFINED CMAKE_CXX_STANDARD OR "${CMAKE_CXX_STANDARD}" STREQUAL "")
             if (ENABLE_XTL_COMPLEX)
diff --git a/test/test_api.cpp b/test/test_api.cpp
@@ -166,9 +166,16 @@ struct xsimd_api_test
     template <class T>
     void test_set_impl(const std::string& name)
     {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#endif
         T v = T(1);
         batch_type expected(v);
         batch_type res = xsimd::broadcast<value_type>(v);
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
         INFO(name);
         CHECK_BATCH_EQ(res, expected);
     }
@@ -187,8 +194,8 @@ struct xsimd_api_test
     {
         vec.resize(size);
 
-        value_type min = value_type(0);
-        value_type max = value_type(100);
+        int min = 0;
+        int max = 100;
 
         std::default_random_engine generator;
         std::uniform_int_distribution<int> distribution(min, max);
diff --git a/test/test_basic_math.cpp b/test/test_basic_math.cpp
@@ -69,7 +69,7 @@ struct basic_math_test
         {
             lhs[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25)) + value_type(1.);
             rhs[i] = value_type(10.2) / (i + 2) + value_type(0.25) + value_type(1.);
-            clip_input[i] = i * value_type(0.25);
+            clip_input[i] = static_cast<value_type>(i) * value_type(0.25);
             from_input[i] = rhs[i] - value_type(1);
         }
     }
diff --git a/test/test_batch.cpp b/test/test_batch.cpp
@@ -746,7 +746,7 @@ struct batch_test
                            {
                                if (std::is_integral<value_type>::value)
                                {
-                                   return ((long long)l + r) / 2;
+                                   return static_cast<value_type>(((long long)l + r) / 2);
                                }
                                else
                                {
@@ -764,7 +764,7 @@ struct batch_test
                            {
                                if (std::is_integral<value_type>::value)
                                {
-                                   return ((long long)l + r) / 2 + ((long long)(l + r) & 1);
+                                   return static_cast<value_type>(((long long)l + r) / 2 + ((long long)(l + r) & 1));
                                }
                                else
                                {
diff --git a/test/test_batch_constant.cpp b/test/test_batch_constant.cpp
@@ -58,7 +58,7 @@ struct constant_batch_test
     {
         static constexpr value_type get(size_t index, size_t /*size*/)
         {
-            return index;
+            return static_cast<value_type>(index);
         }
     };
 
diff --git a/test/test_batch_int.cpp b/test/test_batch_int.cpp
@@ -294,7 +294,7 @@ struct batch_int_test
         lhs = batch_type(std::numeric_limits<value_type>::max());
         for (int32_t i = 0; i < s; ++i)
         {
-            res = lhs >> value_type(i);
+            res = lhs >> i;
             value_type expected = std::numeric_limits<value_type>::max() >> i;
             for (std::size_t j = 0; j < size; ++j)
             {
diff --git a/test/test_batch_manip.cpp b/test/test_batch_manip.cpp
@@ -30,7 +30,7 @@ namespace xsimd
             /* Generate input data */
             for (std::size_t i = 0; i < N; ++i)
             {
-                lhs_in[i] = 2 * i + 1;
+                lhs_in[i] = static_cast<T>(2 * i + 1);
             }
             vects.push_back(std::move(lhs_in));
 
diff --git a/test/test_fp_manipulation.cpp b/test/test_fp_manipulation.cpp
@@ -45,7 +45,7 @@ struct fp_manipulation_test
             array_type expected;
             std::transform(input.cbegin(), input.cend(), expected.begin(),
                            [this](const value_type& v)
-                           { return std::ldexp(v, exponent); });
+                           { return std::ldexp(v, static_cast<int>(exponent)); });
             batch_type res = xsimd::ldexp(batch_input(), bexp);
             INFO("ldexp");
             CHECK_BATCH_EQ(res, expected);
diff --git a/test/test_load_store.cpp b/test/test_load_store.cpp
@@ -269,8 +269,8 @@ struct load_store_test
     {
         vec.resize(size);
 
-        value_type min = value_type(0);
-        value_type max = value_type(100);
+        int min = 0;
+        int max = 100;
 
         std::default_random_engine generator;
         std::uniform_int_distribution<int> distribution(min, max);
diff --git a/test/test_shuffle.cpp b/test/test_shuffle.cpp
@@ -32,8 +32,8 @@ namespace
             /* Generate input data: lhs, rhs */
             for (size_t i = 0; i < N; ++i)
             {
-                lhs_in[i] = 'A' + 2 * i + 1;
-                rhs_in[i] = 'A' + 2 * i;
+                lhs_in[i] = static_cast<T>('A' + 2 * i + 1);
+                rhs_in[i] = static_cast<T>('A' + 2 * i);
             }
             vects.push_back(std::move(lhs_in));
             vects.push_back(std::move(rhs_in));
@@ -288,7 +288,7 @@ struct compress_test
     {
         for (size_t i = 0; i < size; ++i)
         {
-            input[i] = i;
+            input[i] = static_cast<value_type>(i);
         }
     }
 
@@ -360,11 +360,11 @@ TEST_CASE_TEMPLATE("[compress]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint32_t>, x
     }
     // SUBCASE("interleave")
     //{
-    //     Test.interleave();
+    //      Test.interleave();
     // }
     // SUBCASE("generic")
     //{
-    //     Test.generic();
+    //      Test.generic();
     // }
 }
 
@@ -384,7 +384,7 @@ struct expand_test
     {
         for (size_t i = 0; i < size; ++i)
         {
-            input[i] = i;
+            input[i] = static_cast<value_type>(i);
         }
     }
 
@@ -479,8 +479,8 @@ struct shuffle_test
     {
         for (size_t i = 0; i < size; ++i)
         {
-            lhs[i] = i;
-            rhs[i] = i + size;
+            lhs[i] = static_cast<value_type>(i);
+            rhs[i] = static_cast<value_type>(i + size);
         }
     }
 
diff --git a/test/test_xsimd_api.cpp b/test/test_xsimd_api.cpp
@@ -623,7 +623,8 @@ struct xsimd_api_float_types_functions
     {
         value_type val0(4);
         xsimd::as_integer_t<value_type> val1(2);
-        CHECK_EQ(extract(xsimd::ldexp(T(val0), xsimd::as_integer_t<T>(val1))), std::ldexp(val0, val1));
+        using exponent_type = typename std::conditional<std::is_scalar<T>::value, int, xsimd::as_integer_t<T>>::type;
+        CHECK_EQ(extract(xsimd::ldexp(T(val0), exponent_type(val1))), std::ldexp(val0, static_cast<int>(val1)));
     }
     void test_lgamma()
     {

Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ namespace xsimd`
`49`	`49`	`// popcount instruction depending on the arch...`
`50`	`50`	`XSIMD_IF_CONSTEXPR(batch_bool<T, A>::size <= 32)`
`51`	`51`	`{`
`52`		`- uint32_t m32 = m;`
	`52`	`+ uint32_t m32 = static_cast<uint32_t>(m);`
`53`	`53`	`// https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel`
`54`	`54`	`m32 = m32 - ((m32 >> 1) & 0x55555555); // reuse input as temporary`
`55`	`55`	`m32 = (m32 & 0x33333333) + ((m32 >> 2) & 0x33333333); // temp`
Original file line number	Diff line number	Diff line change
`@@ -1021,7 +1021,7 @@ namespace xsimd`
`1021`	`1021`	`*/`
`1022`	`1022`	`namespace detail`
`1023`	`1023`	`{`
`1024`		`- XSIMD_INLINE int mask_lut(int mask)`
	`1024`	`+ XSIMD_INLINE int mask_lut(uint64_t mask)`
`1025`	`1025`	`{`
`1026`	`1026`	`// clang-format off`
`1027`	`1027`	`static const int mask_lut[256] = {`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ struct basic_math_test`
`69`	`69`	`{`
`70`	`70`	`lhs[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25)) + value_type(1.);`
`71`	`71`	`rhs[i] = value_type(10.2) / (i + 2) + value_type(0.25) + value_type(1.);`
`72`		`- clip_input[i] = i * value_type(0.25);`
	`72`	`+ clip_input[i] = static_cast<value_type>(i) * value_type(0.25);`
`73`	`73`	`from_input[i] = rhs[i] - value_type(1);`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -746,7 +746,7 @@ struct batch_test`
`746`	`746`	`{`
`747`	`747`	`if (std::is_integral<value_type>::value)`
`748`	`748`	`{`
`749`		`- return ((long long)l + r) / 2;`
	`749`	`+ return static_cast<value_type>(((long long)l + r) / 2);`
`750`	`750`	`}`
`751`	`751`	`else`
`752`	`752`	`{`
`@@ -764,7 +764,7 @@ struct batch_test`
`764`	`764`	`{`
`765`	`765`	`if (std::is_integral<value_type>::value)`
`766`	`766`	`{`
`767`		`- return ((long long)l + r) / 2 + ((long long)(l + r) & 1);`
	`767`	`+ return static_cast<value_type>(((long long)l + r) / 2 + ((long long)(l + r) & 1));`
`768`	`768`	`}`
`769`	`769`	`else`
`770`	`770`	`{`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ struct constant_batch_test`
`58`	`58`	`{`
`59`	`59`	`static constexpr value_type get(size_t index, size_t /size/)`
`60`	`60`	`{`
`61`		`- return index;`
	`61`	`+ return static_cast<value_type>(index);`
`62`	`62`	`}`
`63`	`63`	`};`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -294,7 +294,7 @@ struct batch_int_test`
`294`	`294`	`lhs = batch_type(std::numeric_limits<value_type>::max());`
`295`	`295`	`for (int32_t i = 0; i < s; ++i)`
`296`	`296`	`{`
`297`		`- res = lhs >> value_type(i);`
	`297`	`+ res = lhs >> i;`
`298`	`298`	`value_type expected = std::numeric_limits<value_type>::max() >> i;`
`299`	`299`	`for (std::size_t j = 0; j < size; ++j)`
`300`	`300`	`{`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ namespace xsimd`
`30`	`30`	`/* Generate input data */`
`31`	`31`	`for (std::size_t i = 0; i < N; ++i)`
`32`	`32`	`{`
`33`		`- lhs_in[i] = 2 * i + 1;`
	`33`	`+ lhs_in[i] = static_cast<T>(2 * i + 1);`
`34`	`34`	`}`
`35`	`35`	`vects.push_back(std::move(lhs_in));`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -269,8 +269,8 @@ struct load_store_test`
`269`	`269`	`{`
`270`	`270`	`vec.resize(size);`
`271`	`271`
`272`		`- value_type min = value_type(0);`
`273`		`- value_type max = value_type(100);`
	`272`	`+ int min = 0;`
	`273`	`+ int max = 100;`
`274`	`274`
`275`	`275`	`std::default_random_engine generator;`
`276`	`276`	`std::uniform_int_distribution<int> distribution(min, max);`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,8 @@ namespace`
`32`	`32`	`/* Generate input data: lhs, rhs */`
`33`	`33`	`for (size_t i = 0; i < N; ++i)`
`34`	`34`	`{`
`35`		`- lhs_in[i] = 'A' + 2 * i + 1;`
`36`		`- rhs_in[i] = 'A' + 2 * i;`
	`35`	`+ lhs_in[i] = static_cast<T>('A' + 2 * i + 1);`
	`36`	`+ rhs_in[i] = static_cast<T>('A' + 2 * i);`
`37`	`37`	`}`
`38`	`38`	`vects.push_back(std::move(lhs_in));`
`39`	`39`	`vects.push_back(std::move(rhs_in));`
`@@ -288,7 +288,7 @@ struct compress_test`
`288`	`288`	`{`
`289`	`289`	`for (size_t i = 0; i < size; ++i)`
`290`	`290`	`{`
`291`		`- input[i] = i;`
	`291`	`+ input[i] = static_cast<value_type>(i);`
`292`	`292`	`}`
`293`	`293`	`}`
`294`	`294`
`@@ -360,11 +360,11 @@ TEST_CASE_TEMPLATE("[compress]", B, BATCH_FLOAT_TYPES, xsimd::batch<uint32_t>, x`
`360`	`360`	`}`
`361`	`361`	`// SUBCASE("interleave")`
`362`	`362`	`//{`
`363`		`- // Test.interleave();`
	`363`	`+ // Test.interleave();`
`364`	`364`	`// }`
`365`	`365`	`// SUBCASE("generic")`
`366`	`366`	`//{`
`367`		`- // Test.generic();`
	`367`	`+ // Test.generic();`
`368`	`368`	`// }`
`369`	`369`	`}`
`370`	`370`
`@@ -384,7 +384,7 @@ struct expand_test`
`384`	`384`	`{`
`385`	`385`	`for (size_t i = 0; i < size; ++i)`
`386`	`386`	`{`
`387`		`- input[i] = i;`
	`387`	`+ input[i] = static_cast<value_type>(i);`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
`@@ -479,8 +479,8 @@ struct shuffle_test`
`479`	`479`	`{`
`480`	`480`	`for (size_t i = 0; i < size; ++i)`
`481`	`481`	`{`
`482`		`- lhs[i] = i;`
`483`		`- rhs[i] = i + size;`
	`482`	`+ lhs[i] = static_cast<value_type>(i);`
	`483`	`+ rhs[i] = static_cast<value_type>(i + size);`
`484`	`484`	`}`
`485`	`485`	`}`
`486`	`486`
Original file line number	Diff line number	Diff line change
`@@ -623,7 +623,8 @@ struct xsimd_api_float_types_functions`
`623`	`623`	`{`
`624`	`624`	`value_type val0(4);`
`625`	`625`	`xsimd::as_integer_t<value_type> val1(2);`
`626`		`- CHECK_EQ(extract(xsimd::ldexp(T(val0), xsimd::as_integer_t<T>(val1))), std::ldexp(val0, val1));`
	`626`	`+ using exponent_type = typename std::conditional<std::is_scalar<T>::value, int, xsimd::as_integer_t<T>>::type;`
	`627`	`+ CHECK_EQ(extract(xsimd::ldexp(T(val0), exponent_type(val1))), std::ldexp(val0, static_cast<int>(val1)));`
`627`	`628`	`}`
`628`	`629`	`void test_lgamma()`
`629`	`630`	`{`