Initial PowerPC support

Author: lu-zero

src/runtime/linux/mod.rs

@@ -20,6 +20,10 @@ fn detect_features_impl<T: FeatureQuery>(x: T) -> usize {
     {
         super::aarch64::detect_features(x)
     }
+    #[cfg(target_arch = "powerpc64")]
+    {
+        super::powerpc64::detect_features(x)
+    }
 }
 
 /// Detects ARM features:

src/runtime/mod.rs

@@ -17,12 +17,18 @@ mod aarch64;
 #[cfg(all(target_arch = "aarch64", target_os = "linux"))]
 pub use self::aarch64::__Feature;
 
+#[cfg(all(target_arch = "powerpc64", target_os = "linux"))]
+#[macro_use]
+mod powerpc64;
+#[cfg(all(target_arch = "powerpc64", target_os = "linux"))]
+pub use self::powerpc64::__Feature;
+
 #[cfg(all(target_os = "linux",
-          any(target_arch = "arm", target_arch = "aarch64")))]
+          any(target_arch = "arm", target_arch = "aarch64", target_arch = "powerpc64")))]
 mod linux;
 
 #[cfg(all(target_os = "linux",
-          any(target_arch = "arm", target_arch = "aarch64")))]
+          any(target_arch = "arm", target_arch = "aarch64", target_arch = "powerpc64")))]
 pub use self::linux::detect_features;
 
 /// Performs run-time feature detection.

src/runtime/powerpc64.rs

@@ -0,0 +1,87 @@
+//! Run-time feature detection on PowerPC64.
+use super::{bit, linux};
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __unstable_detect_feature {
+    ("altivec") => {
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::altivec{})
+    };
+    ("vsx") => {
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::vsx{})
+    };
+    ("power8") => {
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::power8{})
+    };
+    ($t:tt) => { compile_error!(concat!("unknown PowerPC target feature: ", $t)) };
+}
+
+/// PowerPC CPU Feature enum. Each variant denotes a position in a bitset
+/// for a particular feature.
+///
+/// PLEASE: do not use this, it is an implementation detail subject to change.
+#[doc(hidden)]
+#[allow(non_camel_case_types)]
+#[repr(u8)]
+pub enum __Feature {
+    /// Altivec
+    altivec,
+    /// VSX
+    vsx,
+    /// Power8
+    power8,
+}
+
+pub fn detect_features<T: linux::FeatureQuery>(mut x: T) -> usize {
+    let mut value: usize = 0;
+    {
+        let mut enable_feature = |f| {
+            if x.has_feature(&f) {
+                value = bit::set(value, f as u32);
+            }
+        };
+        enable_feature(__Feature::altivec);
+        enable_feature(__Feature::vsx);
+        enable_feature(__Feature::power8);
+    }
+    value
+}
+
+impl linux::FeatureQuery for linux::AuxVec {
+    fn has_feature(&mut self, x: &__Feature) -> bool {
+        use self::__Feature::*;
+        match *x {
+            altivec => self.lookup(linux::AT::HWCAP)
+                .map(|caps| caps & 0x10000000 != 0)
+                .unwrap_or(false),
+            vsx  => self.lookup(linux::AT::HWCAP)
+                .map(|caps| caps & 0x00000080 != 0)
+                .unwrap_or(false),
+            power8 => self.lookup(linux::AT::HWCAP2)
+                .map(|caps| caps & 0x80000000 != 0)
+                .unwrap_or(false),
+        }
+    }
+}
+
+// TODO: This is a dummy linux on ppc does not provide this information
+impl linux::FeatureQuery for linux::CpuInfo {
+    fn has_feature(&mut self, x: &__Feature) -> bool {
+        use self::__Feature::*;
+        match *x {
+            altivec => self.field("Features").has("altivec"),
+            vsx => self.field("Features").has("vsx"),
+            power8 => self.field("Features").has("isa2_7"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn detect_feature() {
+        println!("altivec {}", __unstable_detect_feature!("altivec"));
+        println!("vsx {}", __unstable_detect_feature!("vsx"));
+        println!("power8 {}", __unstable_detect_feature!("power8"));
+    }
+}