fix(cksum): implement proper CPU hardware capability detection for --debug flag

- Add cpufeatures dependency to workspace dependencies (Cargo.toml)
- Create new hardware.rs module with CPU feature detection (AVX512, AVX2, PCLMUL, VMULL)
- Integrate hardware detection into cksum.rs with startup execution
- Update localization strings (en-US.ftl, fr-FR.ftl) to reflect new behavior
- Update tests to verify CPU detection messages instead of algorithm names
- Fix clippy warnings (use_self, uninlined_format_args)
- Ensure fmt compliance

This fixes PR uutils#9088 by correctly implementing GNU cksum's --debug flag behavior,
which outputs CPU hardware capability detection messages to stderr, not algorithm names.

Author: naoNao89

Cargo.lock

@@ -311,6 +311,7 @@ clap = { version = "4.5", features = ["wrap_help", "cargo", "color"] }
 clap_complete = "4.4"
 clap_mangen = "0.2"
 compare = "0.1.0"
+cpufeatures = "0.2"
 crossterm = "0.29.0"
 ctor = "0.6.0"
 ctrlc = { version = "3.4.7", features = ["termination"] }

Cargo.toml

@@ -22,6 +22,7 @@ clap = { workspace = true }
 uucore = { workspace = true, features = ["checksum", "encoding", "sum"] }
 hex = { workspace = true }
 fluent = { workspace = true }
+cpufeatures = { workspace = true }
 
 [[bin]]
 name = "cksum"

src/uu/cksum/Cargo.toml

@@ -27,10 +27,7 @@ cksum-help-status = don't output anything, status code shows success
 cksum-help-quiet = don't print OK for each successfully verified file
 cksum-help-ignore-missing = don't fail or report status for missing files
 cksum-help-zero = end each output line with NUL, not newline, and disable file name escaping
-cksum-help-debug = indicate which algorithm is used
-
-# Debug messages
-cksum-debug-algorithm = {$file}: {$algorithm}
+cksum-help-debug = indicate which implementation is used
 
 # Error messages
 cksum-error-is-directory = { $file }: Is a directory

src/uu/cksum/locales/en-US.ftl

@@ -27,10 +27,7 @@ cksum-help-status = ne rien afficher, le code de statut indique le succès
 cksum-help-quiet = ne pas afficher OK pour chaque fichier vérifié avec succès
 cksum-help-ignore-missing = ne pas échouer ou signaler le statut pour les fichiers manquants
 cksum-help-zero = terminer chaque ligne de sortie avec NUL, pas un saut de ligne, et désactiver l'échappement des noms de fichiers
-cksum-help-debug = indiquer quel algorithme est utilisé
-
-# Messages de débogage
-cksum-debug-algorithm = {$file} : {$algorithm}
+cksum-help-debug = indiquer quelle implémentation est utilisée
 
 # Messages d'erreur
 cksum-error-is-directory = { $file } : Est un répertoire

src/uu/cksum/locales/fr-FR.ftl

@@ -5,8 +5,11 @@
 
 // spell-checker:ignore (ToDO) fname, algo
 
+mod hardware;
+
 use clap::builder::ValueParser;
 use clap::{Arg, ArgAction, Command};
+use hardware::CpuFeatures;
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io::{BufReader, Read, Write, stdin, stdout};
@@ -177,20 +180,11 @@ fn print_untagged_checksum(
     Ok(())
 }
 
-fn print_debug_info(filename: &OsStr, algo_name: &str) {
-    let file_display = if filename == OsStr::new("-") {
-        "standard input".to_string()
-    } else {
-        filename.to_string_lossy().to_string()
-    };
-    eprintln!(
-        "{}",
-        translate!(
-            "cksum-debug-algorithm",
-            "file" => file_display,
-            "algorithm" => algo_name.to_uppercase()
-        )
-    );
+/// Print CPU hardware capability detection information to stderr
+/// This matches GNU cksum's --debug behavior
+fn print_cpu_debug_info() {
+    let features = CpuFeatures::detect();
+    features.print_debug();
 }
 
 /// Calculate checksum
@@ -205,6 +199,11 @@ where
 {
     let mut files = files.peekable();
 
+    // Print CPU debug info once at startup if --debug flag is set
+    if options.debug {
+        print_cpu_debug_info();
+    }
+
     while let Some(filename) = files.next() {
         // Check that in raw mode, we are not provided with several files.
         if options.output_format.is_raw() && files.peek().is_some() {
@@ -237,10 +236,6 @@ where
             Box::new(file_buf) as Box<dyn Read>
         });
 
-        if options.debug {
-            print_debug_info(filename, options.algo_name);
-        }
-
         let (sum_hex, sz) =
             digest_reader(&mut options.digest, &mut file, false, options.output_bits)
                 .map_err_context(|| translate!("cksum-error-failed-to-read-input"))?;

src/uu/cksum/src/cksum.rs

@@ -0,0 +1,148 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! CPU hardware capability detection for cksum --debug
+//!
+//! This module detects available CPU features that affect cksum performance,
+//! matching GNU cksum's --debug behavior.
+
+use std::sync::Once;
+
+/// CPU features that affect cksum performance
+#[derive(Debug, Clone, Copy)]
+pub struct CpuFeatures {
+    pub avx512: bool,
+    pub avx2: bool,
+    pub pclmul: bool,
+    pub vmull: bool,
+}
+
+impl CpuFeatures {
+    /// Detect available CPU features (cached after first call)
+    pub fn detect() -> Self {
+        static ONCE: Once = Once::new();
+        static mut FEATURES: CpuFeatures = CpuFeatures {
+            avx512: false,
+            avx2: false,
+            pclmul: false,
+            vmull: false,
+        };
+
+        unsafe {
+            ONCE.call_once(|| {
+                FEATURES = Self {
+                    avx512: has_avx512(),
+                    avx2: has_avx2(),
+                    pclmul: has_pclmul(),
+                    vmull: has_vmull(),
+                };
+            });
+            FEATURES
+        }
+    }
+
+    /// Print debug information to stderr
+    /// Outputs CPU feature availability in GNU cksum format
+    pub fn print_debug(&self) {
+        self.print_feature("avx512", self.avx512);
+        self.print_feature("avx2", self.avx2);
+        self.print_feature("pclmul", self.pclmul);
+        if cfg!(target_arch = "aarch64") {
+            self.print_feature("vmull", self.vmull);
+        }
+    }
+
+    fn print_feature(&self, name: &str, available: bool) {
+        let status = if available {
+            format!("using {name} hardware support")
+        } else {
+            format!("{name} support not detected")
+        };
+        eprintln!("cksum: {status}");
+    }
+}
+
+// CPU feature detection functions
+// These use cpufeatures crate for cross-platform detection
+
+#[cfg(target_arch = "x86_64")]
+fn has_avx512() -> bool {
+    cpufeatures::has_avx512f() && cpufeatures::has_avx512bw()
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+fn has_avx512() -> bool {
+    false
+}
+
+#[cfg(target_arch = "x86_64")]
+fn has_avx2() -> bool {
+    cpufeatures::has_avx2()
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+fn has_avx2() -> bool {
+    false
+}
+
+#[cfg(target_arch = "x86_64")]
+fn has_pclmul() -> bool {
+    cpufeatures::has_pclmul()
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+fn has_pclmul() -> bool {
+    false
+}
+
+#[cfg(target_arch = "aarch64")]
+fn has_vmull() -> bool {
+    // ARM NEON support detection
+    // This would require platform-specific code
+    // For now, return false as a safe default
+    false
+}
+
+#[cfg(not(target_arch = "aarch64"))]
+fn has_vmull() -> bool {
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cpu_features_detection() {
+        let features = CpuFeatures::detect();
+        // Features should be valid booleans
+        assert!(features.avx512 || !features.avx512);
+        assert!(features.avx2 || !features.avx2);
+        assert!(features.pclmul || !features.pclmul);
+        assert!(features.vmull || !features.vmull);
+    }
+
+    #[test]
+    fn test_cpu_features_cached() {
+        let features1 = CpuFeatures::detect();
+        let features2 = CpuFeatures::detect();
+        // Should return same values (cached)
+        assert_eq!(features1.avx512, features2.avx512);
+        assert_eq!(features1.avx2, features2.avx2);
+        assert_eq!(features1.pclmul, features2.pclmul);
+        assert_eq!(features1.vmull, features2.vmull);
+    }
+
+    #[test]
+    fn test_cpu_features_on_x86_64() {
+        #[cfg(target_arch = "x86_64")]
+        {
+            let features = CpuFeatures::detect();
+            // On x86_64, at least one feature should be detected or all false
+            // (depending on CPU capabilities)
+            let _ = features;
+        }
+    }
+}

src/uu/cksum/src/hardware.rs

@@ -2748,52 +2748,61 @@ mod format_mix {
 
 #[test]
 fn test_debug_flag() {
-    // Test with default CRC algorithm
+    // Test with default CRC algorithm - should output CPU feature detection
     new_ucmd!()
         .arg("--debug")
         .arg("lorem_ipsum.txt")
         .succeeds()
         .stdout_is_fixture("crc_single_file.expected")
-        .stderr_contains("lorem_ipsum.txt: CRC");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 
-    // Test with MD5 algorithm
+    // Test with MD5 algorithm - CPU detection should be same regardless of algorithm
     new_ucmd!()
         .arg("--debug")
         .arg("-a")
         .arg("md5")
         .arg("lorem_ipsum.txt")
         .succeeds()
         .stdout_is_fixture("md5_single_file.expected")
-        .stderr_contains("lorem_ipsum.txt: MD5");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 
-    // Test with stdin
+    // Test with stdin - CPU detection should appear once
     new_ucmd!()
         .arg("--debug")
         .pipe_in("test")
         .succeeds()
-        .stderr_contains("standard input: CRC");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 
-    // Test with multiple files
+    // Test with multiple files - CPU detection should appear once, not per file
     new_ucmd!()
         .arg("--debug")
         .arg("lorem_ipsum.txt")
         .arg("alice_in_wonderland.txt")
         .succeeds()
         .stdout_is_fixture("crc_multiple_files.expected")
-        .stderr_contains("lorem_ipsum.txt: CRC")
-        .stderr_contains("alice_in_wonderland.txt: CRC");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 }
 
 #[test]
 fn test_debug_with_algorithms() {
-    // Test with SHA256
+    // Test with SHA256 - CPU detection should be same regardless of algorithm
     new_ucmd!()
         .arg("--debug")
         .arg("-a")
         .arg("sha256")
         .arg("lorem_ipsum.txt")
         .succeeds()
-        .stderr_contains("lorem_ipsum.txt: SHA256");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 
     // Test with BLAKE2b default length
     new_ucmd!()
@@ -2802,7 +2811,9 @@ fn test_debug_with_algorithms() {
         .arg("blake2b")
         .arg("lorem_ipsum.txt")
         .succeeds()
-        .stderr_contains("lorem_ipsum.txt: BLAKE2B");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 
     // Test with BLAKE2b custom length
     new_ucmd!()
@@ -2813,7 +2824,9 @@ fn test_debug_with_algorithms() {
         .arg("256")
         .arg("lorem_ipsum.txt")
         .succeeds()
-        .stderr_contains("lorem_ipsum.txt: BLAKE2B");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 
     // Test with SHA1
     new_ucmd!()
@@ -2822,5 +2835,7 @@ fn test_debug_with_algorithms() {
         .arg("sha1")
         .arg("lorem_ipsum.txt")
         .succeeds()
-        .stderr_contains("lorem_ipsum.txt: SHA1");
+        .stderr_contains("cksum: avx512 support")
+        .stderr_contains("cksum: avx2 support")
+        .stderr_contains("cksum: pclmul support");
 }