fix allow dead_code for scalar-only targets

Signed-off-by: satyamg1620 <Satyam.Gupta.3@ibm.com>

Author: satyamg1620

src/simd/bits.rs

@@ -14,12 +14,8 @@ macro_rules! impl_bits {
 
                 #[inline]
                 fn as_little_endian(&self) -> Self {
-                    // The bitmask this operates on is produced in software with a
-                    // canonical layout (lane `i` -> bit `i`) on every target — see
-                    // `Mask::bitmask` in `v128.rs`. It carries no byte order to
-                    // convert, so this is the identity on both endiannesses.
-                    // `swap_bytes` on big-endian would reorder bytes without
-                    // reversing bit order, landing `first_offset` on the wrong bit.
+                    // The software bitmask already uses a canonical layout
+                    // (lane `i` -> bit `i`), so there is no byte order to swap.
                     self.clone()
                 }
 

src/simd/traits.rs

@@ -32,6 +32,9 @@ pub trait Mask: Sized + BitOr<Self> + BitOrAssign + BitAnd<Self> {
 /// Trait for the bitmask of a vector Mask.
 pub trait BitMask {
     /// Total bits in the bitmask.
+    // Used only by the wide-SIMD kernels (sse2/avx2/avx512/neon); dead code on
+    // scalar-only targets like s390x that compile just `v128`.
+    #[allow(dead_code)]
     const LEN: usize;
 
     /// get the offset of the first `1` bit.
@@ -41,8 +44,10 @@ pub trait BitMask {
     fn as_little_endian(&self) -> Self;
 
     /// whether all bits are zero.
+    #[allow(dead_code)]
     fn all_zero(&self) -> bool;
 
     /// clear high n bits.
+    #[allow(dead_code)]
     fn clear_high_bits(&self, n: usize) -> Self;
 }

src/simd/v128.rs

@@ -58,12 +58,9 @@ impl Mask for Mask128 {
     type Element = u8;
 
     fn bitmask(self) -> Self::BitMask {
-        // This bitmask is built purely in software from an array, so it has no
-        // inherent byte order: lane `i` maps to bit `i` on every target. The
-        // matching `first_offset` (see `bits.rs`) is a plain `trailing_zeros`,
-        // and the partial-tail clear in `format_string` (`mask & ((1 << nb) -
-        // 1)`) keeps the low `nb` lanes. Reversing the bit order on big-endian
-        // here would break both, so keep a single canonical layout.
+        // Built in software, so the bitmask has no inherent byte order: lane
+        // `i` maps to bit `i` on every target, matching `first_offset`'s plain
+        // `trailing_zeros`.
         self.0
             .iter()
             .enumerate()