avx512bw,vbmi: Use make_batch_constant.

Instead of loading from an aligned array on the stack.
So we yield the `set` instead of `load` intrinsic, which makes it easier for the compiler to constant fold this parts.

Sadly, MSVC needs this....

Author: degasus

include/xsimd/arch/xsimd_avx512bw.hpp

@@ -486,17 +486,22 @@ namespace xsimd
         // slide_left
         namespace detail
         {
-            template <size_t... Is>
-            constexpr std::array<uint64_t, sizeof...(Is)> make_slide_perm_hi(::xsimd::detail::index_sequence<Is...>)
+            struct make_slide_perm_hi
             {
-                return { (Is == 0 ? 8 : Is - 1)... };
-            }
+                static constexpr uint64_t get(size_t i, size_t)
+                {
+                    return i == 0 ? 8 : i - 1;
+                }
+            };
 
-            template <size_t N, size_t... Is>
-            constexpr std::array<uint16_t, sizeof...(Is)> make_slide_left_pattern(::xsimd::detail::index_sequence<Is...>)
+            template <size_t N>
+            struct make_slide_left_pattern
             {
-                return { (Is >= N ? Is - N : 0)... };
-            }
+                static constexpr uint16_t get(size_t i, size_t)
+                {
+                    return i >= N ? i - N : 0;
+                }
+            };
         }
 
         template <size_t N, class A, class T>
@@ -520,10 +525,10 @@ namespace xsimd
                 buffer[0] = buffer[0] << 8;
                 xx = _mm512_load_epi64(&buffer[0]);
 
-                alignas(A::alignment()) auto slide_perm = detail::make_slide_perm_hi(::xsimd::detail::make_index_sequence<512 / 64>());
+                auto slide_perm = xsimd::make_batch_constant<uint64_t, detail::make_slide_perm_hi, A>();
                 __m512i xl = _mm512_slli_epi64(x, 8);
                 __m512i xr = _mm512_srli_epi64(x, 56);
-                xr = _mm512_permutex2var_epi64(xr, _mm512_load_epi64(slide_perm.data()), _mm512_setzero_si512());
+                xr = _mm512_permutex2var_epi64(xr, slide_perm.as_batch(), _mm512_setzero_si512());
                 xx = _mm512_or_si512(xr, xl);
                 if (N == 1)
                     return xx;
@@ -533,24 +538,29 @@ namespace xsimd
                 xx = x;
             }
             __mmask32 mask = 0xFFFFFFFFu << ((N / 2) & 31);
-            alignas(A::alignment()) auto slide_pattern = detail::make_slide_left_pattern<N / 2>(::xsimd::detail::make_index_sequence<512 / 16>());
-            return _mm512_maskz_permutexvar_epi16(mask, _mm512_load_epi32(slide_pattern.data()), xx);
+            auto slide_pattern = xsimd::make_batch_constant<uint16_t, detail::make_slide_left_pattern<N / 2>, A>();
+            return _mm512_maskz_permutexvar_epi16(mask, slide_pattern.as_batch(), xx);
         }
 
         // slide_right
         namespace detail
         {
-            template <size_t... Is>
-            constexpr std::array<uint64_t, sizeof...(Is)> make_slide_perm_low(::xsimd::detail::index_sequence<Is...>)
+            struct make_slide_perm_low
             {
-                return { (Is + 1)... };
-            }
+                static constexpr uint64_t get(size_t i, size_t)
+                {
+                    return i + 1;
+                }
+            };
 
-            template <size_t N, size_t... Is>
-            constexpr std::array<uint16_t, sizeof...(Is)> make_slide_right_pattern(::xsimd::detail::index_sequence<Is...>)
+            template <size_t N>
+            struct make_slide_right_pattern
             {
-                return { (Is < (32 - N) ? Is + N : 0)... };
-            }
+                static constexpr uint16_t get(size_t i, size_t n)
+                {
+                    return i < (n - N) ? i + N : 0;
+                }
+            };
         }
         template <size_t N, class A, class T>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& x, requires_arch<avx512bw>) noexcept
@@ -566,10 +576,10 @@ namespace xsimd
             batch<T, A> xx;
             if (N & 1)
             {
-                alignas(A::alignment()) auto slide_perm = detail::make_slide_perm_low(::xsimd::detail::make_index_sequence<512 / 64>());
+                auto slide_perm = xsimd::make_batch_constant<uint64_t, detail::make_slide_perm_low, A>();
                 __m512i xr = _mm512_srli_epi64(x, 8);
                 __m512i xl = _mm512_slli_epi64(x, 56);
-                xl = _mm512_permutex2var_epi64(xl, _mm512_load_epi64(slide_perm.data()), _mm512_setzero_si512());
+                xl = _mm512_permutex2var_epi64(xl, slide_perm.as_batch(), _mm512_setzero_si512());
                 xx = _mm512_or_si512(xr, xl);
                 if (N == 1)
                     return xx;
@@ -579,8 +589,8 @@ namespace xsimd
                 xx = x;
             }
             __mmask32 mask = 0xFFFFFFFFu >> ((N / 2) & 31);
-            alignas(A::alignment()) auto slide_pattern = detail::make_slide_right_pattern<N / 2>(::xsimd::detail::make_index_sequence<512 / 16>());
-            return _mm512_maskz_permutexvar_epi16(mask, _mm512_load_epi32(slide_pattern.data()), xx);
+            auto slide_pattern = xsimd::make_batch_constant<uint16_t, detail::make_slide_right_pattern<N / 2>, A>();
+            return _mm512_maskz_permutexvar_epi16(mask, slide_pattern.as_batch(), xx);
         }
 
         // ssub

include/xsimd/arch/xsimd_avx512vbmi.hpp

@@ -26,17 +26,23 @@ namespace xsimd
 
         namespace detail
         {
-            template <size_t N, size_t... Is>
-            constexpr std::array<uint8_t, sizeof...(Is)> make_slide_left_bytes_pattern(::xsimd::detail::index_sequence<Is...>)
+            template <size_t N>
+            struct make_slide_left_bytes_pattern
             {
-                return { (Is >= N ? Is - N : 0)... };
-            }
+                static constexpr uint8_t get(size_t i, size_t)
+                {
+                    return i >= N ? i - N : 0;
+                }
+            };
 
-            template <size_t N, size_t... Is>
-            constexpr std::array<uint8_t, sizeof...(Is)> make_slide_right_bytes_pattern(::xsimd::detail::index_sequence<Is...>)
+            template <size_t N>
+            struct make_slide_right_bytes_pattern
             {
-                return { (Is < (64 - N) ? Is + N : 0)... };
-            }
+                static constexpr uint8_t get(size_t i, size_t n)
+                {
+                    return i < (n - N) ? i + N : 0;
+                }
+            };
         }
 
         // slide_left
@@ -53,8 +59,8 @@ namespace xsimd
             }
 
             __mmask64 mask = 0xFFFFFFFFFFFFFFFFull << (N & 63);
-            alignas(A::alignment()) auto slide_pattern = detail::make_slide_left_bytes_pattern<N>(::xsimd::detail::make_index_sequence<512 / 8>());
-            return _mm512_maskz_permutexvar_epi8(mask, _mm512_load_epi32(slide_pattern.data()), x);
+            auto slide_pattern = xsimd::make_batch_constant<uint8_t, detail::make_slide_left_bytes_pattern<N>, A>();
+            return _mm512_maskz_permutexvar_epi8(mask, slide_pattern.as_batch(), x);
         }
 
         // slide_right
@@ -70,8 +76,8 @@ namespace xsimd
                 return batch<T, A>(T(0));
             }
             __mmask64 mask = 0xFFFFFFFFFFFFFFFFull >> (N & 63);
-            alignas(A::alignment()) auto slide_pattern = detail::make_slide_right_bytes_pattern<N>(::xsimd::detail::make_index_sequence<512 / 8>());
-            return _mm512_maskz_permutexvar_epi8(mask, _mm512_load_epi32(slide_pattern.data()), x);
+            auto slide_pattern = xsimd::make_batch_constant<uint8_t, detail::make_slide_right_bytes_pattern<N>, A>();
+            return _mm512_maskz_permutexvar_epi8(mask, slide_pattern.as_batch(), x);
         }
 
         // swizzle (dynamic version)