Implement optimized movemasks for NEON

While the scalar post-processing required to obtain one bit per lane
makes this more expensive than directly supporting variable-sized bit
groups (as done in Zstandard[^1]), the result is still an improvement
over the current lane-by-lane algorithm.

[^1]: See facebook/zstd#3139, namely `ZSTD_row_matchMaskGroupWidth`.

Author: onalante-ebay

include/xsimd/arch/xsimd_neon.hpp

@@ -3278,6 +3278,80 @@ namespace xsimd
             return { batch<widen_t<T>, A>(vaddl_u32(vget_low_u32(x), vdup_n_u32(0))), batch<widen_t<T>, A>(vaddl_u32(vget_high_u32(x), vdup_n_u32(0))) };
         }
 
+        /********
+         * mask *
+         ********/
+        template <class A, class T>
+        XSIMD_INLINE uint64_t mask(batch_bool<T, A> const& self, requires_arch<neon>) noexcept
+        {
+#ifdef XSIMD_LITTLE_ENDIAN
+            static constexpr bool do_swap = false;
+#else
+            static constexpr bool do_swap = true;
+#endif
+
+            XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
+            {
+                uint8x16_t inner = self;
+                XSIMD_IF_CONSTEXPR(do_swap)
+                {
+                    inner = vrev16q_u8(inner);
+                }
+
+                uint16x8_t pairs = vreinterpretq_u16_u8(inner);
+                uint8x8_t narrowed = vshrn_n_u16(pairs, 4);
+                XSIMD_IF_CONSTEXPR(do_swap)
+                {
+                    narrowed = vrev64_u8(narrowed);
+                }
+
+                uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(narrowed), 0);
+                mask &= 0x1111111111111111;
+                mask = mask | mask >> 3;
+                mask = (mask | mask >> 6) & 0x000F000F000F000F;
+                mask = (mask | mask >> 12) & 0x000000FF000000FF;
+                return (mask | mask >> 24) & 0xFFFF;
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
+            {
+                uint8x8_t narrowed = vmovn_u16(self);
+                XSIMD_IF_CONSTEXPR(do_swap)
+                {
+                    narrowed = vrev64_u8(narrowed);
+                }
+
+                uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(narrowed), 0);
+                mask &= 0x0101010101010101;
+                mask = mask | mask >> 7;
+                mask = mask | mask >> 14;
+                return (mask | mask >> 28) & 0xFF;
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
+            {
+                uint16x4_t narrowed = vmovn_u32(self);
+                XSIMD_IF_CONSTEXPR(do_swap)
+                {
+                    narrowed = vrev64_u16(narrowed);
+                }
+
+                uint64_t mask = vget_lane_u64(vreinterpret_u64_u16(narrowed), 0);
+                mask &= 0x0001000100010001;
+                mask = mask | mask >> 15;
+                return (mask | mask >> 30) & 0xF;
+            }
+            else
+            {
+                uint32x2_t narrowed = vmovn_u64(self);
+                XSIMD_IF_CONSTEXPR(do_swap)
+                {
+                    narrowed = vrev64_u32(narrowed);
+                }
+
+                uint64_t mask32 = vget_lane_u64(vreinterpret_u64_u32(narrowed), 0);
+                mask32 &= 0x0000000100000001;
+                return (mask32 | mask32 >> 31) & 0x3;
+            }
+        }
     }
 
 }

include/xsimd/config/xsimd_config.hpp

@@ -16,6 +16,17 @@
 #define XSIMD_VERSION_MINOR 0
 #define XSIMD_VERSION_PATCH 0
 
+#if defined(__GNUC__) && defined(__BYTE_ORDER__)
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define XSIMD_LITTLE_ENDIAN
+#endif
+#elif defined(_WIN32)
+// We can safely assume that Windows is always little endian
+#define XSIMD_LITTLE_ENDIAN
+#elif defined(i386) || defined(i486) || defined(intel) || defined(x86) || defined(i86pc) || defined(__alpha) || defined(__osf__)
+#define XSIMD_LITTLE_ENDIAN
+#endif
+
 /**
  * high level free functions
  *

include/xsimd/math/xsimd_rem_pio2.hpp

@@ -47,17 +47,6 @@ namespace xsimd
          * ====================================================
          */
 
-#if defined(__GNUC__) && defined(__BYTE_ORDER__)
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define XSIMD_LITTLE_ENDIAN
-#endif
-#elif defined(_WIN32)
-        // We can safely assume that Windows is always little endian
-#define XSIMD_LITTLE_ENDIAN
-#elif defined(i386) || defined(i486) || defined(intel) || defined(x86) || defined(i86pc) || defined(__alpha) || defined(__osf__)
-#define XSIMD_LITTLE_ENDIAN
-#endif
-
 #ifdef XSIMD_LITTLE_ENDIAN
 #define LOW_WORD_IDX 0
 #define HIGH_WORD_IDX sizeof(std::uint32_t)
@@ -708,7 +697,6 @@ namespace xsimd
         }
     }
 
-#undef XSIMD_LITTLE_ENDIAN
 #undef SET_LOW_WORD
 #undef SET_HIGH_WORD
 #undef GET_LOW_WORD