Add -Werror mode and use it for testing

serge-sans-paille · serge-sans-paille · commit db1406a465b8 · 2021-03-23T15:02:02.000+01:00
Enabled through -DXSIMD_ENABLE_WERROR, and used for validation to prevent further `regression` Fix #417
diff --git a/.azure-pipelines/unix-build.yml b/.azure-pipelines/unix-build.yml
@@ -39,7 +39,7 @@ steps:
         CMAKE_EXTRA_ARGS="$CMAKE_EXTRA_ARGS -DXSIMD_FORCE_X86_INSTR_SET=0 -DXSIMD_FORCE_X86_AMD_INSTR_SET=0";
       fi
 
-      cmake -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX $CMAKE_EXTRA_ARGS -DDOWNLOAD_GTEST=ON $(Build.SourcesDirectory)
+      cmake -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX $CMAKE_EXTRA_ARGS -DDOWNLOAD_GTEST=ON -DXSIMD_ENABLE_WERROR=1 $(Build.SourcesDirectory)
     displayName: Configure xsimd
     workingDirectory: $(Build.BinariesDirectory)
 
diff --git a/include/xsimd/config/xsimd_instruction_set.hpp b/include/xsimd/config/xsimd_instruction_set.hpp
@@ -52,34 +52,42 @@
 #ifdef XSIMD_FORCE_X86_INSTR_SET
     #define XSIMD_X86_INSTR_SET XSIMD_FORCE_X86_INSTR_SET
     #define XSIMD_X86_INSTR_SET_AVAILABLE XSIMD_VERSION_NUMBER_AVAILABLE
-    #ifdef _MSC_VER
-        #pragma message("Warning: Forcing X86 instruction set")
-    #else
-        #warning "Forcing X86 instruction set"
+    #ifndef XSIMD_SKIP_ON_WERROR
+        #ifdef _MSC_VER
+            #pragma message("Warning: Forcing X86 instruction set")
+        #else
+            #warning "Forcing X86 instruction set"
+        #endif
     #endif
 #elif defined(XSIMD_FORCE_X86_AMD_INSTR_SET)
     #define XSIMD_X86_AMD_INSTR_SET XSIMD_FORCE_X86_AMD_INSTR_SET
     #define XSIMD_X86_AMD_INSTR_SET_AVAILABLE XSIMD_VERSION_NUMBER_AVAILABLE
-    #ifdef _MSC_VER
-        #pragma message("Warning: Forcing X86 AMD instruction set")
-    #else
-        #warning "Forcing X86 AMD instruction set"
+    #ifndef XSIMD_SKIP_ON_WERROR
+        #ifdef _MSC_VER
+            #pragma message("Warning: Forcing X86 AMD instruction set")
+        #else
+            #warning "Forcing X86 AMD instruction set"
+        #endif
     #endif
 #elif defined(XSIMD_FORCE_PPC_INSTR_SET)
     #define XSIMD_PPC_INSTR_SET XSIMD_FORCE_PPC_INSTR_SET
     #define XSIMD_PPC_INSTR_SET_AVAILABLE XSIMD_VERSION_NUMBER_AVAILABLE
-    #ifdef _MSC_VER
-        #pragma message("Warning: Forcing PPC instruction set")
-    #else
-        #warning "Forcing PPC instruction set"
+    #ifndef XSIMD_SKIP_ON_WERROR
+        #ifdef _MSC_VER
+            #pragma message("Warning: Forcing PPC instruction set")
+        #else
+            #warning "Forcing PPC instruction set"
+        #endif
     #endif
 #elif defined(XSIMD_FORCE_ARM_INSTR_SET)
     #define XSIMD_ARM_INSTR_SET XSIMD_FORCE_ARM_INSTR_SET
     #define XSIMD_ARM_INSTR_SET_AVAILABLE XSIMD_VERSION_NUMBER_AVAILABLE
-    #ifdef _MSC_VER
-        #pragma message("Warning: Forcing ARM instruction set")
-    #else
-        #warning "Forcing ARM instruction set"
+    #ifndef XSIMD_SKIP_ON_WERROR
+        #ifdef _MSC_VER
+            #pragma message("Warning: Forcing ARM instruction set")
+        #else
+            #warning "Forcing ARM instruction set"
+        #endif
     #endif
 #endif
 
diff --git a/include/xsimd/types/xsimd_avx_float.hpp b/include/xsimd/types/xsimd_avx_float.hpp
@@ -707,7 +707,7 @@ namespace xsimd
             }
 
             template<bool... Values>
-            static batch_type select(const batch_bool_constant<value_type, Values...>& cond, const batch_type& a, const batch_type& b)
+            static batch_type select(const batch_bool_constant<value_type, Values...>&, const batch_type& a, const batch_type& b)
             {
                 constexpr int mask = batch_bool_constant<value_type, Values...>::mask();
                 return _mm256_blend_ps(b, a, mask);
diff --git a/include/xsimd/types/xsimd_base_constant.hpp b/include/xsimd/types/xsimd_base_constant.hpp
@@ -29,7 +29,7 @@ namespace xsimd
 
         bool operator[](size_t i) const
         {
-            return std::array<value_type, size>{Values...}[i];
+            return std::array<value_type, size>{{Values...}}[i];
         }
         static constexpr int mask()
         {
diff --git a/include/xsimd/types/xsimd_fallback.hpp b/include/xsimd/types/xsimd_fallback.hpp
@@ -603,7 +603,8 @@ namespace xsimd
             {
                 T res(0);
                 using int_type = as_unsigned_integer_t<T>;
-                *reinterpret_cast<int_type*>(&res) = ~int_type(0);
+                int_type value(~int_type(0));
+                std::memcpy(&res, &value, sizeof(int_type));
                 return res;
             }
         };
diff --git a/include/xsimd/types/xsimd_sse_double.hpp b/include/xsimd/types/xsimd_sse_double.hpp
@@ -633,6 +633,7 @@ namespace xsimd
             static batch_type select(const batch_bool_constant<value_type, Values...>& cond, const batch_type& a, const batch_type& b)
             {
 #if XSIMD_X86_INSTR_SET >= XSIMD_X86_SSE4_1_VERSION
+                (void)cond;
                 constexpr int mask = batch_bool_constant<value_type, Values...>::mask();
                 return _mm_blend_pd(b, a, mask);
 #else
diff --git a/include/xsimd/types/xsimd_types_include.hpp b/include/xsimd/types/xsimd_types_include.hpp
@@ -70,18 +70,21 @@
 #endif
 
 #if !defined(XSIMD_INSTR_SET_AVAILABLE)
-    #if defined(XSIMD_ENABLE_FALLBACK)
-        #ifdef _MSC_VER
-	    #pragma message("Warning: No SIMD instructions set detected, using fallback mode.")
-        #else
-	    #warning "No SIMD instructions set detected, using fallback mode."
-        #endif
-    #else
-        #ifdef _MSC_VER
-	    #pragma message("Warning: No SIMD instructions set detected, please enable SIMD instructions or activate the fallback mode. (e.g. for x86 -march=native or for ARM -mfpu=neon)")
+    #ifndef XSIMD_SKIP_ON_WERROR
+
+        #if defined(XSIMD_ENABLE_FALLBACK)
+            #ifdef _MSC_VER
+	              #pragma message("Warning: No SIMD instructions set detected, using fallback mode.")
+            #else
+	              #warning "No SIMD instructions set detected, using fallback mode."
+            #endif
         #else
-	    #warning "No SIMD instructions set detected, please enable SIMD instructions or activate the fallback mode. (e.g. for x86 -march=native or for ARM -mfpu=neon)"
-	#endif
+            #ifdef _MSC_VER
+	              #pragma message("Warning: No SIMD instructions set detected, please enable SIMD instructions or activate the fallback mode. (e.g. for x86 -march=native or for ARM -mfpu=neon)")
+            #else
+	              #warning "No SIMD instructions set detected, please enable SIMD instructions or activate the fallback mode. (e.g. for x86 -march=native or for ARM -mfpu=neon)"
+	          #endif
+	      #endif
     #endif
 #endif
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -30,6 +30,8 @@ include(CheckCXXCompilerFlag)
 
 string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE)
 
+OPTION(XSIMD_ENABLE_WERROR "Turn on -Werror" OFF)
+
 ################
 # ARM SETTINGS #
 ################
@@ -239,3 +241,7 @@ if (CROSS_COMPILE_ARM)
 else()
     add_custom_target(xtest COMMAND test_xsimd DEPENDS test_xsimd)
 endif()
+
+if (XSIMD_ENABLE_WERROR)
+    target_compile_options(test_xsimd PRIVATE -Werror -Wall -DXSIMD_SKIP_ON_WERROR)
+endif()
diff --git a/test/test_algorithms.cpp b/test/test_algorithms.cpp
@@ -263,6 +263,7 @@ TEST(algorithms, iterator)
     *cbegin = sin(*cbegin);
     *cbegin = sqrt(*cbegin);
     auto real_part = abs(*(cbegin));
+    (void)real_part;
 #endif
 
 }
diff --git a/test/test_basic_math.cpp b/test/test_basic_math.cpp
@@ -98,8 +98,8 @@ class basic_math_test : public testing::Test
         }
         // clip
         {
-            value_type clip_lo = 0.5;
-            value_type clip_hi = 1.;
+            value_type clip_lo = static_cast<value_type>(0.5);
+            value_type clip_hi = static_cast<value_type>(1.);
             array_type expected;
             std::transform(clip_input.cbegin(), clip_input.cend(), expected.begin(),
                            [clip_lo, clip_hi](const value_type& l) {
diff --git a/test/test_batch_int.cpp b/test/test_batch_int.cpp
@@ -32,7 +32,7 @@ namespace xsimd
 
             T max = std::numeric_limits<T>::max();
             T min = std::numeric_limits<T>::min();
-            std::array<T, 2> maxmin_cmp{max, min};
+            std::array<T, 2> maxmin_cmp{{max, min}};
             B maxmin(max, min);
             EXPECT_BATCH_EQ(maxmin, maxmin_cmp) << print_function_name("numeric max and min");
 
@@ -43,8 +43,8 @@ namespace xsimd
             auto r1 = xsimd::max(a, c);
             auto r3 = xsimd::min(a, c);
 
-            EXPECT_BATCH_EQ(r1, A({2, 3})) << print_function_name("max");
-            EXPECT_BATCH_EQ(r3, A({1, 3})) << print_function_name("min");
+            EXPECT_BATCH_EQ(r1, (A{{2, 3}})) << print_function_name("max");
+            EXPECT_BATCH_EQ(r3, (A{{1, 3}})) << print_function_name("min");
 
             auto r4 = a < b; // test lt
             BB e4(1, 0);
@@ -68,8 +68,8 @@ namespace xsimd
             auto r1 = xsimd::max(a, c);
             auto r3 = xsimd::min(a, c);
 
-            EXPECT_BATCH_EQ(r1, A({2, 3, 2, 3})) << print_function_name("max");
-            EXPECT_BATCH_EQ(r3, A({1, 3, 1, 1})) << print_function_name("min");
+            EXPECT_BATCH_EQ(r1, (A{{2, 3, 2, 3}})) << print_function_name("max");
+            EXPECT_BATCH_EQ(r3, (A{{1, 3, 1, 1}})) << print_function_name("min");
 
             auto r4 = a < b; // test lt
             BB e4(1,0,1,1);
@@ -88,7 +88,7 @@ namespace xsimd
 
             T max = std::numeric_limits<T>::max();
             T min = std::numeric_limits<T>::min();
-            std::array<T, 8> maxmin_cmp{0, 0, max, 0, min, 0, 0, 0};
+            std::array<T, 8> maxmin_cmp{{0, 0, max, 0, min, 0, 0, 0}};
             B maxmin(0, 0, max, 0, min, 0, 0, 0);
             EXPECT_BATCH_EQ(maxmin, maxmin_cmp) << print_function_name("numeric max and min");
 
@@ -99,8 +99,8 @@ namespace xsimd
             auto r1 = xsimd::max(a, c);
             auto r3 = xsimd::min(a, c);
             auto r4 = a < b; // test lt
-            EXPECT_BATCH_EQ(r1, A({2, 3, 2, 3, 2, 3, 3, 3})) << print_function_name("max");
-            EXPECT_BATCH_EQ(r3, A({1, 3, 1, 3, 1, 1, 2, 3})) << print_function_name("min");
+            EXPECT_BATCH_EQ(r1, (A{{2, 3, 2, 3, 2, 3, 3, 3}})) << print_function_name("max");
+            EXPECT_BATCH_EQ(r3, (A{{1, 3, 1, 3, 1, 1, 2, 3}})) << print_function_name("min");
 
             BB e4(1,0,1,0, 1,1,0,0);
             EXPECT_TRUE(xsimd::all(r4 == e4));
@@ -118,7 +118,7 @@ namespace xsimd
 
             T max = std::numeric_limits<T>::max();
             T min = std::numeric_limits<T>::min();
-            std::array<T, 16> maxmin_cmp{0, 0, max, 0, min, 0, 0, 0, 0, 0, max, 0, min, 0, 0, 0};
+            std::array<T, 16> maxmin_cmp{{0, 0, max, 0, min, 0, 0, 0, 0, 0, max, 0, min, 0, 0, 0}};
             B maxmin(0, 0, max, 0, min, 0, 0, 0, 0, 0, max, 0, min, 0, 0, 0);
             EXPECT_BATCH_EQ(maxmin, maxmin_cmp) << print_function_name("numeric max and min");
 
@@ -131,8 +131,8 @@ namespace xsimd
             auto r5 = a == c;
             auto r6 = a != c;
 
-            EXPECT_BATCH_EQ(r1, A({2,3,2,3, 2,3,2,3, 3,3,3,3, 2,max,max,2})) << print_function_name("max");
-            EXPECT_BATCH_EQ(r3, A({1,2,1,2, 1,2,1,2, 2,2,2,2, min,2,2,min})) << print_function_name("min");
+            EXPECT_BATCH_EQ(r1, (A{{2,3,2,3, 2,3,2,3, 3,3,3,3, 2,max,max,2}})) << print_function_name("max");
+            EXPECT_BATCH_EQ(r3, (A{{1,2,1,2, 1,2,1,2, 2,2,2,2, min,2,2,min}})) << print_function_name("min");
 
             BB e4(1,0,1,0, 1,0,1,0, 0,0,0,0, 1,0,0,1);
             EXPECT_TRUE(xsimd::all(r4 == e4));
@@ -161,8 +161,8 @@ namespace xsimd
             auto r1 = xsimd::max(a, b);
             auto r3 = xsimd::min(a, b);
             auto r4 = a < b; // test lt
-            EXPECT_BATCH_EQ(r1, A({2,3,2,3, 2,3,2,3, 2,3,2,3, 2,3,2,3, 2,3,2,3, 2,3,2,3, 3,3,3,3, 2,max,max,2})) << print_function_name("max");
-            EXPECT_BATCH_EQ(r3, A({1,2,1,2, 1,2,1,2, 1,2,1,2, 1,2,1,2, 1,2,1,2, 1,2,1,2, 2,2,2,2, min,2,2,min})) << print_function_name("min");
+            EXPECT_BATCH_EQ(r1, (A{{2,3,2,3, 2,3,2,3, 2,3,2,3, 2,3,2,3, 2,3,2,3, 2,3,2,3, 3,3,3,3, 2,max,max,2}})) << print_function_name("max");
+            EXPECT_BATCH_EQ(r3, (A{{1,2,1,2, 1,2,1,2, 1,2,1,2, 1,2,1,2, 1,2,1,2, 1,2,1,2, 2,2,2,2, min,2,2,min}})) << print_function_name("min");
 
             BB e4(1,0,1,0, 1,0,1,0, 1,0,1,0, 1,0,1,0, 1,0,1,0, 1,0,1,0, 0,0,0,0, 1,0,0,1);
             EXPECT_TRUE(xsimd::all(r4 == e4));
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
@@ -133,28 +133,36 @@ namespace detail
         }
     }
 
-    template <class T>
-    inline T uabs(T val)
+    inline unsigned char uabs(unsigned char val)
     {
-        return std::abs(val);
+        return val;
     }
 
-    inline uint32_t uabs(uint32_t val)
+    inline unsigned short uabs(unsigned short val)
     {
         return val;
     }
 
-    inline uint64_t uabs(uint64_t val)
+    inline unsigned int uabs(unsigned int val)
     {
         return val;
     }
 
-#ifdef XSIMD_32_BIT_ABI
     inline unsigned long uabs(unsigned long val)
     {
         return val;
     }
-#endif
+
+    inline unsigned long long uabs(unsigned long long val)
+    {
+        return val;
+    }
+
+    template <class T>
+    inline T uabs(T val)
+    {
+        return std::abs(val);
+    }
 
     template <class T>
     bool check_is_small(const T& value, const T& tolerance)
@@ -170,9 +178,9 @@ namespace detail
         {
             return (std::numeric_limits<T>::max)();
         }
-        if (lhs == static_cast<T>(0) ||
-            rhs > static_cast<T>(1) &&
-                lhs < rhs * (std::numeric_limits<T>::min)())
+        if ((lhs == static_cast<T>(0)) ||
+            (rhs > static_cast<T>(1) &&
+                lhs < rhs * (std::numeric_limits<T>::min)()))
         {
             return static_cast<T>(0);
         }

Original file line number	Diff line number	Diff line change
`@@ -707,7 +707,7 @@ namespace xsimd`
`707`	`707`	`}`
`708`	`708`
`709`	`709`	`template<bool... Values>`
`710`		`- static batch_type select(const batch_bool_constant<value_type, Values...>& cond, const batch_type& a, const batch_type& b)`
	`710`	`+ static batch_type select(const batch_bool_constant<value_type, Values...>&, const batch_type& a, const batch_type& b)`
`711`	`711`	`{`
`712`	`712`	`constexpr int mask = batch_bool_constant<value_type, Values...>::mask();`
`713`	`713`	`return _mm256_blend_ps(b, a, mask);`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ namespace xsimd`
`29`	`29`
`30`	`30`	`bool operator[](size_t i) const`
`31`	`31`	`{`
`32`		`- return std::array<value_type, size>{Values...}[i];`
	`32`	`+ return std::array<value_type, size>{{Values...}}[i];`
`33`	`33`	`}`
`34`	`34`	`static constexpr int mask()`
`35`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -603,7 +603,8 @@ namespace xsimd`
`603`	`603`	`{`
`604`	`604`	`T res(0);`
`605`	`605`	`using int_type = as_unsigned_integer_t<T>;`
`606`		`- reinterpret_cast<int_type>(&res) = ~int_type(0);`
	`606`	`+ int_type value(~int_type(0));`
	`607`	`+ std::memcpy(&res, &value, sizeof(int_type));`
`607`	`608`	`return res;`
`608`	`609`	`}`
`609`	`610`	`};`
Original file line number	Diff line number	Diff line change
`@@ -633,6 +633,7 @@ namespace xsimd`
`633`	`633`	`static batch_type select(const batch_bool_constant<value_type, Values...>& cond, const batch_type& a, const batch_type& b)`
`634`	`634`	`{`
`635`	`635`	`#if XSIMD_X86_INSTR_SET >= XSIMD_X86_SSE4_1_VERSION`
	`636`	`+ (void)cond;`
`636`	`637`	`constexpr int mask = batch_bool_constant<value_type, Values...>::mask();`
`637`	`638`	`return _mm_blend_pd(b, a, mask);`
`638`	`639`	`#else`
Original file line number	Diff line number	Diff line change
`@@ -263,6 +263,7 @@ TEST(algorithms, iterator)`
`263`	`263`	`cbegin = sin(cbegin);`
`264`	`264`	`cbegin = sqrt(cbegin);`
`265`	`265`	`auto real_part = abs(*(cbegin));`
	`266`	`+ (void)real_part;`
`266`	`267`	`#endif`
`267`	`268`
`268`	`269`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,8 +98,8 @@ class basic_math_test : public testing::Test`
`98`	`98`	`}`
`99`	`99`	`// clip`
`100`	`100`	`{`
`101`		`- value_type clip_lo = 0.5;`
`102`		`- value_type clip_hi = 1.;`
	`101`	`+ value_type clip_lo = static_cast<value_type>(0.5);`
	`102`	`+ value_type clip_hi = static_cast<value_type>(1.);`
`103`	`103`	`array_type expected;`
`104`	`104`	`std::transform(clip_input.cbegin(), clip_input.cend(), expected.begin(),`
`105`	`105`	`[clip_lo, clip_hi](const value_type& l) {`