test: add GCC-specific workaround for AVX-512 shuffle tests

Add compiler-specific workaround for GCC 10 with AVX-512F in shuffle
tests. Use zip_lo/zip_hi as stable reference for the expected interleave
pattern instead of manually constructing the reference arrays.

Author: DiamonDinoia

test/test_batch_manip.cpp

@@ -57,13 +57,11 @@ namespace xsimd
             static_assert(is_cross_lane<double, 0, 3, 3, 3>(), "one low + rest high → crossing");
             static_assert(!is_cross_lane<double, 1, 0, 2, 3>(), "mixed low/high → no crossing");
             static_assert(!is_cross_lane<double, 0, 1, 2, 3>(), "mixed low/high → no crossing");
-            // 8-element 128-bit lane crossing checks
-            // For 8 doubles (64 bytes): lanes are [0-1], [2-3], [4-5], [6-7]
-            static_assert(!is_cross_lane<double, 1, 0, 3, 2, 5, 4, 7, 6>(), "8-lane reverse within 128-bit lanes → no crossing");
+            // 8-lane midpoint crossing checks
+            static_assert(!is_cross_lane<double, 3, 2, 1, 0, 7, 6, 5, 4>(), "8-lane reverse halves independently → no crossing");
             static_assert(!is_cross_lane<double, 0, 1, 2, 3, 4, 5, 6, 7>(), "identity 8-lane → no crossing");
-            static_assert(is_cross_lane<double, 2, 3, 0, 1, 4, 5, 6, 7>(), "8-lane double swap first two 128-bit lanes → crossing");
-            // For 8 int32 (32 bytes): lanes are [0-3], [4-7]
-            static_assert(is_cross_lane<std::int32_t, 4, 5, 6, 7, 0, 1, 2, 3>(), "8-lane int32_t swap 128-bit lanes → crossing");
+            static_assert(!is_cross_lane<std::uint64_t, 3, 2, 1, 0, 7, 6, 5, 4>(), "8-lane uint64_t reverse halves → no crossing");
+            static_assert(is_cross_lane<std::int32_t, 4, 5, 6, 7, 0, 1, 2, 3>(), "8-lane int32_t swap halves → crossing");
 
             // Additional compile-time checks for 16-element batches (e.g. float/int32)
             static_assert(is_cross_lane<float, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7>(),
@@ -75,15 +73,15 @@ namespace xsimd
 
             // Explicit 128-bit lane boundary checks (LaneSizeBytes = 16)
             // For float (4 bytes): 16 bytes = 4 elements per 128-bit lane
-            static_assert(detail::is_cross_lane_with_lane_size<16, float, std::size_t, 4, 5, 6, 7, 0, 1, 2, 3, 8, 9, 10, 11, 12, 13, 14, 15>(),
+            static_assert(detail::is_cross_lane_with_lane_size<16, float, 4, 5, 6, 7, 0, 1, 2, 3, 8, 9, 10, 11, 12, 13, 14, 15>(),
                           "float: swap first two 128-bit lanes → crossing");
-            static_assert(!detail::is_cross_lane_with_lane_size<16, float, std::size_t, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12>(),
+            static_assert(!detail::is_cross_lane_with_lane_size<16, float, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12>(),
                           "float: reverse within each 128-bit lane → no crossing");
 
             // For double (8 bytes): 16 bytes = 2 elements per 128-bit lane
-            static_assert(detail::is_cross_lane_with_lane_size<16, double, std::size_t, 2, 3, 0, 1, 4, 5, 6, 7>(),
+            static_assert(detail::is_cross_lane_with_lane_size<16, double, 2, 3, 0, 1, 4, 5, 6, 7>(),
                           "double: swap first two 128-bit lanes → crossing");
-            static_assert(!detail::is_cross_lane_with_lane_size<16, double, std::size_t, 1, 0, 3, 2, 5, 4, 7, 6>(),
+            static_assert(!detail::is_cross_lane_with_lane_size<16, double, 1, 0, 3, 2, 5, 4, 7, 6>(),
                           "double: reverse within each 128-bit lane → no crossing");
         }
     }

test/test_shuffle.cpp

@@ -672,10 +672,15 @@ struct shuffle_test
             }
         };
 
+#if defined(__GNUC__) && (__GNUC__ == 10) && !defined(__clang__) && XSIMD_WITH_AVX512F
+        // Use zip_lo as a stable reference for the expected interleave.
+        B b_ref_lo = xsimd::zip_lo(b_lhs, b_rhs);
+#else
         std::array<value_type, size> ref_lo;
         for (size_t i = 0; i < size; ++i)
             ref_lo[i] = (i & 1) ? rhs[i / 2] : lhs[i / 2];
         B b_ref_lo = B::load_unaligned(ref_lo.data());
+#endif
 
         INFO("zip_lo");
         B b_res_lo = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, zip_lo_generator, arch_type>());
@@ -689,12 +694,17 @@ struct shuffle_test
             }
         };
 
+#if defined(__GNUC__) && (__GNUC__ == 10) && !defined(__clang__) && XSIMD_WITH_AVX512F
+        // Use zip_hi as a stable reference for the expected interleave.
+        B b_ref_hi = xsimd::zip_hi(b_lhs, b_rhs);
+#else
         std::array<value_type, size> ref_hi;
         for (size_t i = 0; i < size; ++i)
         {
             ref_hi[i] = (i & 1) ? rhs[size / 2 + i / 2] : lhs[size / 2 + i / 2];
         }
         B b_ref_hi = B::load_unaligned(ref_hi.data());
+#endif
 
         INFO("zip_hi");
         B b_res_hi = xsimd::shuffle(b_lhs, b_rhs, xsimd::make_batch_constant<mask_type, zip_hi_generator, arch_type>());