detect: Minor cleanups

Author: taiki-e

src/imp/atomic128/aarch64.rs

@@ -142,7 +142,6 @@ mod detect;
 
 // test only
 #[cfg(test)]
-#[cfg(not(qemu))]
 #[cfg(not(valgrind))]
 #[cfg(not(portable_atomic_no_outline_atomics))]
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]

src/imp/detect/aarch64_aa64reg.rs

@@ -31,9 +31,10 @@ For now, this module is only used on NetBSD/OpenBSD.
 
 On Linux/Android/FreeBSD, we use auxv.rs and this module is test-only because:
 - On Linux/Android, this approach requires a higher kernel version than Rust supports,
-  and also does not work with qemu-user (as of 7.2) and Valgrind (as of 3.19).
+  and also does not work with qemu-user (as of 7.2) and Valgrind (as of 3.24).
   (Looking into HWCAP_CPUID in auxvec, it appears that Valgrind is setting it
   to false correctly, but qemu-user is setting it to true.)
+  - qemu-user issue seem to be fixed as of 9.2.
 - On FreeBSD, this approach does not work on FreeBSD 12 on QEMU (confirmed on
   FreeBSD 12.{2,3,4}), and we got SIGILL (worked on FreeBSD 13 and 14).
 */

src/imp/detect/aarch64_illumos.rs

@@ -42,12 +42,14 @@ fn _detect(info: &mut CpuInfo) {
         ffi::getisax(out.as_mut_ptr(), OUT_LEN);
     }
     macro_rules! check {
-        ($flag:ident, $index:tt, $bit:ident) => {
-            if out[$index] & ffi::$bit != 0 {
+        ($v:ident, $flag:ident, $bit:ident) => {
+            if $v & ffi::$bit != 0 {
                 info.set(CpuInfoFlag::$flag);
             }
         };
     }
-    check!(lse, 0, AV_AARCH64_LSE);
-    check!(lse2, 1, AV_AARCH64_2_LSE2);
+    let v1 = out[0];
+    check!(v1, lse, AV_AARCH64_LSE);
+    let v2 = out[1];
+    check!(v2, lse2, AV_AARCH64_2_LSE2);
 }

src/imp/detect/auxv.rs

@@ -437,6 +437,15 @@ mod arch {
         // OpenBSD 7.6+
         // https://github.com/openbsd/src/commit/ef873df06dac50249b2dd380dc6100eee3b0d23d
         pub(crate) const HWCAP_ATOMICS: ffi::c_ulong = 1 << 8;
+        // Linux 4.11+
+        // https://github.com/torvalds/linux/commit/77c97b4ee21290f5f083173d957843b615abbff2
+        // FreeBSD 13.0+/12.2+
+        // https://github.com/freebsd/freebsd-src/blob/release/13.0.0/sys/arm64/include/elf.h
+        // https://github.com/freebsd/freebsd-src/blob/release/12.2.0/sys/arm64/include/elf.h
+        // OpenBSD 7.6+
+        // https://github.com/openbsd/src/commit/ef873df06dac50249b2dd380dc6100eee3b0d23d
+        #[cfg(test)]
+        pub(crate) const HWCAP_CPUID: ffi::c_ulong = 1 << 11;
         // Linux 4.17+
         // https://github.com/torvalds/linux/commit/7206dc93a58fb76421c4411eefa3c003337bcb2d
         // FreeBSD 13.0+/12.2+
@@ -484,25 +493,25 @@ mod arch {
             }
         }
 
-        let hwcap = os::getauxval(ffi::AT_HWCAP);
-
-        if hwcap & HWCAP_ATOMICS != 0 {
-            info.set(CpuInfoFlag::lse);
-        }
-        if hwcap & HWCAP_USCAT != 0 {
-            info.set(CpuInfoFlag::lse2);
+        macro_rules! check {
+            ($v:ident, $flag:ident, $bit:ident) => {
+                if $v & $bit != 0 {
+                    info.set(CpuInfoFlag::$flag);
+                }
+            };
         }
+        let hwcap = os::getauxval(ffi::AT_HWCAP);
+        check!(hwcap, lse, HWCAP_ATOMICS);
+        check!(hwcap, lse2, HWCAP_USCAT);
+        #[cfg(test)]
+        check!(hwcap, cpuid, HWCAP_CPUID);
         #[cfg(not(target_os = "openbsd"))]
         // HWCAP2 is not yet available on ILP32: https://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux.git/tree/arch/arm64/include/uapi/asm/hwcap.h?h=staging/ilp32-5.1
         #[cfg(target_pointer_width = "64")]
         {
             let hwcap2 = os::getauxval(ffi::AT_HWCAP2);
-            if hwcap2 & HWCAP2_LRCPC3 != 0 {
-                info.set(CpuInfoFlag::rcpc3);
-            }
-            if hwcap2 & HWCAP2_LSE128 != 0 {
-                info.set(CpuInfoFlag::lse128);
-            }
+            check!(hwcap2, rcpc3, HWCAP2_LRCPC3);
+            check!(hwcap2, lse128, HWCAP2_LSE128);
         }
     }
 }
@@ -808,7 +817,7 @@ mod tests {
             let mut digits = release.split('.');
             let major = digits.next().unwrap().parse::<u32>().unwrap();
             let minor = digits.next().unwrap().parse::<u32>().unwrap();
-            // TODO: qemu-user bug?
+            // TODO: qemu-user bug (fails even on kernel >= 6.4) (as of 9.2)
             if (major, minor) < (6, 4) || cfg!(qemu) {
                 std::eprintln!("kernel version: {}.{} (no pr_get_auxv)", major, minor);
                 assert_eq!(getauxval_pr_get_auxv_libc(ffi::AT_HWCAP).unwrap_err(), -1);
@@ -822,7 +831,7 @@ mod tests {
                     -libc::EINVAL
                 );
             } else if cfg!(valgrind) {
-                // TODO: valgrind bug
+                // TODO: valgrind bug (result value mismatch) (as of 3.24)
             } else {
                 std::eprintln!("kernel version: {}.{} (has pr_get_auxv)", major, minor);
                 assert_eq!(

src/imp/detect/common.rs

@@ -87,7 +87,7 @@ macro_rules! flags {
     };
 }
 
-// rustc definitions: https://github.com/rust-lang/rust/blob/e6af292f91f21f12ac1aab6825efb7e1e3381cbb/compiler/rustc_target/src/target_features.rs#L179
+// rustc definitions: https://github.com/rust-lang/rust/blob/e6af292f91f21f12ac1aab6825efb7e1e3381cbb/compiler/rustc_target/src/target_features.rs
 
 // LLVM definitions: https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/llvm/lib/Target/AArch64/AArch64Features.td
 #[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
@@ -126,6 +126,9 @@ flags! {
     // > If FEAT_LSFE is implemented, then FEAT_FP is implemented.
     #[cfg(test)]
     lsfe("lsfe", any(target_feature /* N/A */, portable_atomic_target_feature)),
+
+    #[cfg(test)] // test-only
+    cpuid("cpuid", any(/* no corresponding target feature */)),
 }
 
 // LLVM definitions: https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/llvm/lib/Target/PowerPC/PPC.td
@@ -152,15 +155,6 @@ flags! {
     vmovdqa_atomic("vmovdqa-atomic", any(/* no corresponding target feature */)),
 }
 
-// Static assertions for C type definitions.
-// Assertions with core::ffi types are in crate::utils::ffi module.
-#[cfg(test)]
-#[cfg(not(any(windows, target_arch = "x86", target_arch = "x86_64")))]
-const _: fn() = || {
-    use test_helper::sys;
-    let _: crate::utils::ffi::c_char = 0 as sys::c_char;
-};
-
 #[allow(
     clippy::alloc_instead_of_core,
     clippy::std_instead_of_alloc,
@@ -226,6 +220,14 @@ mod tests_common {
         test_helper::eprintln_nocapture!("{}", features);
     }
 
+    // Static assertions for C type definitions.
+    // Assertions with core::ffi types are in crate::utils::ffi module.
+    #[cfg(not(any(windows, target_arch = "x86", target_arch = "x86_64")))]
+    const _: fn() = || {
+        use test_helper::sys;
+        let _: crate::utils::ffi::c_char = 0 as sys::c_char;
+    };
+
     #[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
     #[allow(clippy::collapsible_else_if)]
     #[test]

src/imp/detect/riscv_linux.rs

@@ -110,8 +110,8 @@ fn _detect(info: &mut CpuInfo) {
     if riscv_hwprobe(&mut out) && out.key != -1 {
         let value = out.value;
         macro_rules! check {
-            ($flag:ident, $hwprobe_bit:ident) => {
-                if value & ffi::$hwprobe_bit != 0 {
+            ($flag:ident, $bit:ident) => {
+                if value & ffi::$bit != 0 {
                     info.set(CpuInfoFlag::$flag);
                 }
             };