fix: centralize fast-math reassociation barriers

DiamonDinoia · DiamonDinoia · commit 6d3a9742eb88 · 2026-03-20T14:57:50.000-04:00
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
@@ -92,6 +92,37 @@ jobs:
         run: |
           cd _build && ./test/test_xsimd
 
+  build-windows-clang-cl-fast-math:
+    name: 'clang-cl 19 x64 /fp:fast'
+    defaults:
+      run:
+        shell: bash {0}
+    runs-on: windows-2025
+    steps:
+    - name: Setup compiler
+      uses: ilammy/msvc-dev-cmd@v1
+      with:
+        arch: amd64
+    - name: Setup LLVM 19
+      run: |
+        choco install llvm --version=19.1.7 -y --no-progress
+    - name: Setup Ninja
+      run: |
+        python3 -m pip install --upgrade pip setuptools wheel
+        python3 -m pip install ninja
+    - name: Checkout xsimd
+      uses: actions/checkout@v3
+    - name: Setup
+      run: |
+        mkdir _build
+        cd _build && cmake .. -DBUILD_TESTS=ON -DDOWNLOAD_DOCTEST=ON -DBUILD_BENCHMARK=OFF -DBUILD_EXAMPLES=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER="C:/Program Files/LLVM/bin/clang-cl.exe" -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang-cl.exe" -DCMAKE_CXX_FLAGS="/fp:fast" -G Ninja
+    - name: Build
+      run: |
+        cd _build && cmake --build .
+    - name: Testing xsimd
+      run: |
+        cd _build && ./test/test_xsimd
+
   build-windows-arm64:
     name: 'MSVC arm64'
     defaults:
diff --git a/include/xsimd/arch/common/xsimd_common_details.hpp b/include/xsimd/arch/common/xsimd_common_details.hpp
@@ -111,26 +111,20 @@ namespace xsimd
 
         namespace detail
         {
-            template <class A>
-            XSIMD_INLINE memory_barrier_tag barrier_tag(A const&) noexcept
-            {
-                return {};
-            }
-
             template <class T>
             XSIMD_INLINE void reassociation_barrier(T& x, memory_barrier_tag) noexcept
             {
-#if XSIMD_WITH_GNU_INLINE_ASM
+#if XSIMD_WITH_INLINE_ASM
                 __asm__ volatile("" : : "r"(&x) : "memory");
 #else
                 (void)x;
 #endif
             }
 
             template <class T, class A>
-            XSIMD_INLINE void reassociation_barrier(T& x, A const& arch) noexcept
+            XSIMD_INLINE void reassociation_barrier(T& x, A const&) noexcept
             {
-                detail::reassociation_barrier(x, detail::barrier_tag(arch));
+                detail::reassociation_barrier(x, memory_barrier_tag {});
             }
 
             template <class F, class A, class T, class... Batches>
diff --git a/include/xsimd/arch/xsimd_avx.hpp b/include/xsimd/arch/xsimd_avx.hpp
@@ -37,11 +37,6 @@ namespace xsimd
 
         namespace detail
         {
-            XSIMD_INLINE x86_barrier_tag barrier_tag(avx const&) noexcept
-            {
-                return {};
-            }
-
             XSIMD_INLINE __m128i lower_half(__m256i self) noexcept
             {
                 return _mm256_castsi256_si128(self);
diff --git a/include/xsimd/arch/xsimd_avx2.hpp b/include/xsimd/arch/xsimd_avx2.hpp
@@ -15,7 +15,6 @@
 #include <complex>
 #include <type_traits>
 
-#include "./xsimd_common_fwd.hpp"
 #include "../types/xsimd_avx2_register.hpp"
 #include "../types/xsimd_batch_constant.hpp"
 #include "./utils/shifts.hpp"
diff --git a/include/xsimd/arch/xsimd_avx512f.hpp b/include/xsimd/arch/xsimd_avx512f.hpp
@@ -42,11 +42,6 @@ namespace xsimd
 
         namespace detail
         {
-            XSIMD_INLINE x86_barrier_tag barrier_tag(avx512f const&) noexcept
-            {
-                return {};
-            }
-
             XSIMD_INLINE __m256 lower_half(__m512 self) noexcept
             {
                 return _mm512_castps512_ps256(self);
diff --git a/include/xsimd/arch/xsimd_common_fwd.hpp b/include/xsimd/arch/xsimd_common_fwd.hpp
@@ -23,30 +23,13 @@ namespace xsimd
     class batch;
     template <class T, class A>
     class batch_bool;
-
     namespace kernel
     {
         namespace detail
         {
             struct memory_barrier_tag
             {
             };
-
-            struct x86_barrier_tag
-            {
-            };
-
-            struct arm_barrier_tag
-            {
-            };
-
-            struct vsx_barrier_tag
-            {
-            };
-
-            struct rvv_barrier_tag
-            {
-            };
         }
     }
     template <class T, class A, T... Vs>
@@ -127,9 +110,6 @@ namespace xsimd
         // Forward declarations for pack-level helpers
         namespace detail
         {
-            template <class A>
-            XSIMD_INLINE memory_barrier_tag barrier_tag(A const&) noexcept;
-
             template <class T>
             XSIMD_INLINE void reassociation_barrier(T& x, memory_barrier_tag) noexcept;
 
@@ -150,7 +130,6 @@ namespace xsimd
             XSIMD_INLINE constexpr bool is_only_from_lo(batch_constant<T, A, Vs...>) noexcept;
             template <typename T, class A, T... Vs>
             XSIMD_INLINE constexpr bool is_only_from_hi(batch_constant<T, A, Vs...>) noexcept;
-
         }
     }
 }
diff --git a/include/xsimd/arch/xsimd_neon.hpp b/include/xsimd/arch/xsimd_neon.hpp
@@ -159,21 +159,6 @@ namespace xsimd
 
         namespace detail
         {
-            XSIMD_INLINE arm_barrier_tag barrier_tag(neon const&) noexcept
-            {
-                return {};
-            }
-
-            template <class T>
-            XSIMD_INLINE void reassociation_barrier(T& x, arm_barrier_tag) noexcept
-            {
-#if XSIMD_WITH_GNU_INLINE_ASM
-                __asm__ volatile("" : "+w"(x));
-#else
-                detail::reassociation_barrier(x, memory_barrier_tag {});
-#endif
-            }
-
             template <template <class> class return_type, class... T>
             struct neon_dispatcher_base
             {
diff --git a/include/xsimd/arch/xsimd_neon64.hpp b/include/xsimd/arch/xsimd_neon64.hpp
@@ -709,7 +709,7 @@ namespace xsimd
             return vcvtnq_s32_f32(self);
         }
 
-#if !XSIMD_WITH_GNU_INLINE_ASM
+#if !defined(__GNUC__)
         template <class A>
         XSIMD_INLINE batch<int64_t, A> nearbyint_as_int(batch<double, A> const& self,
                                                         requires_arch<neon64>) noexcept
diff --git a/include/xsimd/arch/xsimd_rvv.hpp b/include/xsimd/arch/xsimd_rvv.hpp
@@ -289,21 +289,6 @@ namespace xsimd
     {
         namespace detail
         {
-            XSIMD_INLINE rvv_barrier_tag barrier_tag(rvv const&) noexcept
-            {
-                return {};
-            }
-
-            template <class T>
-            XSIMD_INLINE void reassociation_barrier(T& x, rvv_barrier_tag) noexcept
-            {
-#if XSIMD_WITH_GNU_INLINE_ASM
-                __asm__ volatile("" : "+vr"(x));
-#else
-                detail::reassociation_barrier(x, memory_barrier_tag {});
-#endif
-            }
-
             template <class T>
             using rvv_fix_char_t = types::detail::rvv_fix_char_t<T>;
             template <class T, size_t Width = XSIMD_RVV_BITS>
diff --git a/include/xsimd/arch/xsimd_sse2.hpp b/include/xsimd/arch/xsimd_sse2.hpp
@@ -37,21 +37,6 @@ namespace xsimd
 
         namespace detail
         {
-            XSIMD_INLINE x86_barrier_tag barrier_tag(sse2 const&) noexcept
-            {
-                return {};
-            }
-
-            template <class T>
-            XSIMD_INLINE void reassociation_barrier(T& x, x86_barrier_tag) noexcept
-            {
-#if XSIMD_WITH_GNU_INLINE_ASM && XSIMD_TARGET_X86
-                __asm__ volatile("" : "+x"(x));
-#else
-                detail::reassociation_barrier(x, memory_barrier_tag {});
-#endif
-            }
-
             constexpr uint32_t shuffle(uint32_t w, uint32_t x, uint32_t y, uint32_t z)
             {
                 return (z << 6) | (y << 4) | (x << 2) | w;
@@ -731,6 +716,8 @@ namespace xsimd
                 __m128i mask = _mm_setr_epi16(0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000);
                 __m128i xL = _mm_or_si128(_mm_and_si128(mask, x), _mm_andnot_si128(mask, _mm_castpd_si128(_mm_set1_pd(0x0010000000000000)))); //  2^52
                 __m128d f = _mm_sub_pd(_mm_castsi128_pd(xH), _mm_set1_pd(19342813118337666422669312.)); //  2^84 + 2^52
+                // Prevent -ffast-math from reassociating (xH-C)+xL into xH+(xL-C).
+                detail::reassociation_barrier(f, sse2 {});
                 return _mm_add_pd(f, _mm_castsi128_pd(xL));
             }
 
@@ -745,6 +732,8 @@ namespace xsimd
                 __m128i mask = _mm_setr_epi16(0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000);
                 __m128i xL = _mm_or_si128(_mm_and_si128(mask, x), _mm_andnot_si128(mask, _mm_castpd_si128(_mm_set1_pd(0x0010000000000000)))); //  2^52
                 __m128d f = _mm_sub_pd(_mm_castsi128_pd(xH), _mm_set1_pd(442726361368656609280.)); //  3*2^67 + 2^52
+                // Prevent -ffast-math from reassociating (xH-C)+xL into xH+(xL-C).
+                detail::reassociation_barrier(f, sse2 {});
                 return _mm_add_pd(f, _mm_castsi128_pd(xL));
             }
 
diff --git a/include/xsimd/arch/xsimd_sse4_1.hpp b/include/xsimd/arch/xsimd_sse4_1.hpp
@@ -14,7 +14,6 @@
 
 #include <type_traits>
 
-#include "./xsimd_common_fwd.hpp"
 #include "../types/xsimd_sse4_1_register.hpp"
 #include "./common/xsimd_common_cast.hpp"
 
diff --git a/include/xsimd/arch/xsimd_sve.hpp b/include/xsimd/arch/xsimd_sve.hpp
@@ -27,11 +27,6 @@ namespace xsimd
     {
         namespace detail
         {
-            XSIMD_INLINE arm_barrier_tag barrier_tag(sve const&) noexcept
-            {
-                return {};
-            }
-
             using xsimd::index;
             using xsimd::types::detail::sve_vector_type;
 
diff --git a/include/xsimd/arch/xsimd_vsx.hpp b/include/xsimd/arch/xsimd_vsx.hpp
@@ -34,24 +34,6 @@ namespace xsimd
 
     namespace kernel
     {
-        namespace detail
-        {
-            XSIMD_INLINE vsx_barrier_tag barrier_tag(vsx const&) noexcept
-            {
-                return {};
-            }
-
-            template <class T>
-            XSIMD_INLINE void reassociation_barrier(T& x, vsx_barrier_tag) noexcept
-            {
-#if XSIMD_WITH_GNU_INLINE_ASM
-                __asm__ volatile("" : "+wa"(x));
-#else
-                detail::reassociation_barrier(x, memory_barrier_tag {});
-#endif
-            }
-        }
-
         template <class A, class T>
         XSIMD_INLINE batch<T, A> avg(batch<T, A> const&, batch<T, A> const&, requires_arch<common>) noexcept;
         template <class A, class T>
diff --git a/include/xsimd/config/xsimd_config.hpp b/include/xsimd/config/xsimd_config.hpp
@@ -47,18 +47,22 @@
 /**
  * @ingroup xsimd_config_macro
  *
- * Set to 1 if GNU-style extended inline assembly is available, to 0 otherwise.
+ * Set to 1 if GNU-style inline assembly is available, to 0 otherwise.
  */
-/* clang-cl runs in MSVC-compatibility mode and does not define __GNUC__
- * by default. Clang only emits __GNUC__ when GNUCVersion != 0:
- * https://github.com/llvm/llvm-project/blob/main/clang/lib/Frontend/InitPreprocessor.cpp
+/* Use __clang__ || __GNUC__ for GNU-style inline asm. clang-cl runs in
+ * MSVC-compatibility mode and does not define __GNUC__ by default, but it
+ * still defines __clang__. Clang documents __asm__/__asm__ support and broad
+ * GCC-extension compatibility:
+ * https://clang.llvm.org/docs/LanguageExtensions.html
+ * Clang only emits __GNUC__ when GNUCVersion != 0:
+ * https://raw.githubusercontent.com/llvm/llvm-project/main/clang/lib/Frontend/InitPreprocessor.cpp
  * and GNUCVersion defaults to 0:
- * https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/LangOptions.def
- * Clang still supports GNU-style extended asm there. */
-#if defined(__GNUC__) || defined(__clang__)
-#define XSIMD_WITH_GNU_INLINE_ASM 1
+ * https://raw.githubusercontent.com/llvm/llvm-project/main/clang/include/clang/Basic/LangOptions.def
+ */
+#if defined(__clang__) || defined(__GNUC__)
+#define XSIMD_WITH_INLINE_ASM 1
 #else
-#define XSIMD_WITH_GNU_INLINE_ASM 0
+#define XSIMD_WITH_INLINE_ASM 0
 #endif
 
 /**
diff --git a/include/xsimd/config/xsimd_cpu_features_x86.hpp b/include/xsimd/config/xsimd_cpu_features_x86.hpp
@@ -533,7 +533,7 @@ namespace xsimd
             __cpuid(buf, leaf);
             std::memcpy(reg.data(), buf, sizeof(buf));
 
-#elif XSIMD_WITH_GNU_INLINE_ASM
+#elif XSIMD_WITH_INLINE_ASM
 
 #if defined(__i386__) && defined(__PIC__)
             // %ebx may be the PIC register
@@ -561,7 +561,7 @@ namespace xsimd
 #error "_MSC_VER < 1400 is not supported"
 #endif
 
-#elif XSIMD_WITH_GNU_INLINE_ASM
+#elif XSIMD_WITH_INLINE_ASM
             x86_reg32_t xcr0 = {};
             __asm__(
                 "xorl %%ecx, %%ecx\n"
diff --git a/test/test_arch.cpp b/test/test_arch.cpp
@@ -25,10 +25,6 @@ static_assert(xsimd::supported_architectures::contains<xsimd::default_arch>(), "
 static_assert(xsimd::all_architectures::contains<xsimd::default_arch>(), "default arch is a valid arch");
 #endif
 
-#if defined(__clang__) && defined(_MSC_VER)
-static_assert(XSIMD_WITH_GNU_INLINE_ASM, "clang-cl should expose GNU-style inline asm support");
-#endif
-
 #if !XSIMD_WITH_SVE
 static_assert((std::is_base_of<xsimd::neon64, xsimd::default_arch>::value || !xsimd::neon64::supported()), "on arm, without sve, the best we can do is neon64");
 #endif

Original file line number	Diff line number	Diff line change
`@@ -111,26 +111,20 @@ namespace xsimd`
`111`	`111`
`112`	`112`	`namespace detail`
`113`	`113`	`{`
`114`		`- template <class A>`
`115`		`- XSIMD_INLINE memory_barrier_tag barrier_tag(A const&) noexcept`
`116`		`- {`
`117`		`- return {};`
`118`		`- }`
`119`		`-`
`120`	`114`	`template <class T>`
`121`	`115`	`XSIMD_INLINE void reassociation_barrier(T& x, memory_barrier_tag) noexcept`
`122`	`116`	`{`
`123`		`-#if XSIMD_WITH_GNU_INLINE_ASM`
	`117`	`+#if XSIMD_WITH_INLINE_ASM`
`124`	`118`	`__asm__ volatile("" : : "r"(&x) : "memory");`
`125`	`119`	`#else`
`126`	`120`	`(void)x;`
`127`	`121`	`#endif`
`128`	`122`	`}`
`129`	`123`
`130`	`124`	`template <class T, class A>`
`131`		`- XSIMD_INLINE void reassociation_barrier(T& x, A const& arch) noexcept`
	`125`	`+ XSIMD_INLINE void reassociation_barrier(T& x, A const&) noexcept`
`132`	`126`	`{`
`133`		`- detail::reassociation_barrier(x, detail::barrier_tag(arch));`
	`127`	`+ detail::reassociation_barrier(x, memory_barrier_tag {});`
`134`	`128`	`}`
`135`	`129`
`136`	`130`	`template <class F, class A, class T, class... Batches>`
Original file line number	Diff line number	Diff line change
`@@ -37,11 +37,6 @@ namespace xsimd`
`37`	`37`
`38`	`38`	`namespace detail`
`39`	`39`	`{`
`40`		`- XSIMD_INLINE x86_barrier_tag barrier_tag(avx const&) noexcept`
`41`		`- {`
`42`		`- return {};`
`43`		`- }`
`44`		`-`
`45`	`40`	`XSIMD_INLINE __m128i lower_half(__m256i self) noexcept`
`46`	`41`	`{`
`47`	`42`	`return _mm256_castsi256_si128(self);`
Original file line number	Diff line number	Diff line change
`@@ -42,11 +42,6 @@ namespace xsimd`
`42`	`42`
`43`	`43`	`namespace detail`
`44`	`44`	`{`
`45`		`- XSIMD_INLINE x86_barrier_tag barrier_tag(avx512f const&) noexcept`
`46`		`- {`
`47`		`- return {};`
`48`		`- }`
`49`		`-`
`50`	`45`	`XSIMD_INLINE __m256 lower_half(__m512 self) noexcept`
`51`	`46`	`{`
`52`	`47`	`return _mm512_castps512_ps256(self);`
Original file line number	Diff line number	Diff line change
`@@ -23,30 +23,13 @@ namespace xsimd`
`23`	`23`	`class batch;`
`24`	`24`	`template <class T, class A>`
`25`	`25`	`class batch_bool;`
`26`		`-`
`27`	`26`	`namespace kernel`
`28`	`27`	`{`
`29`	`28`	`namespace detail`
`30`	`29`	`{`
`31`	`30`	`struct memory_barrier_tag`
`32`	`31`	`{`
`33`	`32`	`};`
`34`		`-`
`35`		`- struct x86_barrier_tag`
`36`		`- {`
`37`		`- };`
`38`		`-`
`39`		`- struct arm_barrier_tag`
`40`		`- {`
`41`		`- };`
`42`		`-`
`43`		`- struct vsx_barrier_tag`
`44`		`- {`
`45`		`- };`
`46`		`-`
`47`		`- struct rvv_barrier_tag`
`48`		`- {`
`49`		`- };`
`50`	`33`	`}`
`51`	`34`	`}`
`52`	`35`	`template <class T, class A, T... Vs>`
`@@ -127,9 +110,6 @@ namespace xsimd`
`127`	`110`	`// Forward declarations for pack-level helpers`
`128`	`111`	`namespace detail`
`129`	`112`	`{`
`130`		`- template <class A>`
`131`		`- XSIMD_INLINE memory_barrier_tag barrier_tag(A const&) noexcept;`
`132`		`-`
`133`	`113`	`template <class T>`
`134`	`114`	`XSIMD_INLINE void reassociation_barrier(T& x, memory_barrier_tag) noexcept;`
`135`	`115`
`@@ -150,7 +130,6 @@ namespace xsimd`
`150`	`130`	`XSIMD_INLINE constexpr bool is_only_from_lo(batch_constant<T, A, Vs...>) noexcept;`
`151`	`131`	`template <typename T, class A, T... Vs>`
`152`	`132`	`XSIMD_INLINE constexpr bool is_only_from_hi(batch_constant<T, A, Vs...>) noexcept;`
`153`		`-`
`154`	`133`	`}`
`155`	`134`	`}`
`156`	`135`	`}`
Original file line number	Diff line number	Diff line change
`@@ -709,7 +709,7 @@ namespace xsimd`
`709`	`709`	`return vcvtnq_s32_f32(self);`
`710`	`710`	`}`
`711`	`711`
`712`		`-#if !XSIMD_WITH_GNU_INLINE_ASM`
	`712`	`+#if !defined(__GNUC__)`
`713`	`713`	`template <class A>`
`714`	`714`	`XSIMD_INLINE batch<int64_t, A> nearbyint_as_int(batch<double, A> const& self,`
`715`	`715`	`requires_arch<neon64>) noexcept`