Extract the cpu capabilities from the auxiliary vector

Check for neon/asimd and pmull for arm and aarch64.

Author: lu-zero

src/runtime/aarch64.rs

@@ -45,6 +45,20 @@ pub fn detect_features<T: linux::FeatureQuery>(mut x: T) -> usize {
     value
 }
 
+impl linux::FeatureQuery for linux::AuxVec {
+    fn has_feature(&mut self, x: &__Feature) -> bool {
+        use self::__Feature::*;
+        if let Some(caps) = self.lookup(linux::AT::HWCAP) {
+            match *x {
+                asimd => caps & (1 << 1) != 0,
+                pmull => caps & (1 << 4) != 0,
+            }
+        } else {
+            false
+        }
+    }
+}
+
 impl linux::FeatureQuery for linux::CpuInfo {
     fn has_feature(&mut self, x: &__Feature) -> bool {
         use self::__Feature::*;

src/runtime/arm.rs

@@ -42,6 +42,20 @@ pub fn detect_features<T: linux::FeatureQuery>(mut x: T) -> usize {
     value
 }
 
+impl linux::FeatureQuery for linux::AuxVec {
+    fn has_feature(&mut self, x: &__Feature) -> bool {
+        use self::__Feature::*;
+        match *x {
+            neon => self.lookup(linux::AT::HWCAP)
+                .map(|caps| caps & (1 << 12) != 0)
+                .unwrap_or(false),
+            pmull => self.lookup(linux::AT::HWCAP2)
+                .map(|caps| caps & (1 << 4) != 0)
+                .unwrap_or(false),
+        }
+    }
+}
+
 /// Is the CPU known to have a broken NEON unit?
 ///
 /// See https://crbug.com/341598.

src/runtime/linux/auxvec.rs

@@ -0,0 +1,75 @@
+//! Reads /proc/self/auxv on Linux systems
+
+use std::prelude::v1::*;
+use std::slice;
+use std::mem;
+use std::fmt;
+
+pub struct AuxVec {
+    raw: Vec<usize>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+#[allow(dead_code)]
+pub enum AT {
+    PLATFORM = 15,
+    HWCAP = 16,
+    HWCAP2 = 26,
+}
+
+impl fmt::Debug for AuxVec {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_list()
+            .entries(self.raw.chunks(2).map(|kv| (kv[0], kv[1])))
+            .finish()
+    }
+}
+
+impl AuxVec {
+    /// Reads /proc/self/auxv into AuxVec.
+    // TODO: make it less ugly if possible
+    pub fn new() -> Result<Self, ::std::io::Error> {
+        use std::io::Read;
+        let mut file = ::std::fs::File::open("/proc/self/auxv")?;
+        let mut buf = [0usize; 64];
+        let mut raw = unsafe {
+            slice::from_raw_parts_mut(
+                buf.as_mut_ptr() as *mut u8,
+                buf.len() * mem::size_of::<usize>(),
+            )
+        };
+        let l = file.read(&mut raw)? / mem::size_of::<usize>();
+
+        mem::forget(raw);
+
+        let mut v = Vec::new();
+
+        v.extend_from_slice(&buf[..l]);
+
+        Ok(AuxVec { raw: v })
+    }
+
+    /// Returns the value for the AT key.
+    pub fn lookup(&self, key: AT) -> Option<usize> {
+        let k = key as usize;
+        for el in self.raw.chunks(2) {
+            if el[0] == k {
+                return Some(el[1]);
+            }
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn test_auxvec_linux() {
+        let auxvec = AuxVec::new().unwrap();
+        println!("{:?}", auxvec.lookup(AT::HWCAP));
+        println!("{:?}", auxvec);
+    }
+}

src/runtime/linux/mod.rs

@@ -2,6 +2,9 @@
 mod cpuinfo;
 pub use self::cpuinfo::CpuInfo;
 
+mod auxvec;
+pub use self::auxvec::*;
+
 use super::__Feature;
 
 pub trait FeatureQuery {
@@ -21,7 +24,10 @@ fn detect_features_impl<T: FeatureQuery>(x: T) -> usize {
 
 /// Detects ARM features:
 pub fn detect_features() -> usize {
-    // FIXME: use libc::getauxval, and if that fails /proc/auxv
+    // Try to read /proc/self/auxv
+    if let Ok(v) = auxvec::AuxVec::new() {
+        return detect_features_impl(v);
+    }
     // Try to read /proc/cpuinfo
     if let Ok(v) = cpuinfo::CpuInfo::new() {
         return detect_features_impl(v);