[arm] runtime-detection support

Author: gnzlbg

.travis.yml

@@ -1,6 +1,10 @@
 language: rust
 sudo: false
 rust: nightly
+services: docker
+git:
+  depth: 1
+  submodules: false
 
 matrix:
   fast_finish: true

Cross.toml

@@ -0,0 +1,7 @@
+[build.env]
+passthrough = [
+    "RUST_BACKTRACE",
+    "RUST_LOG",
+    "TRAVIS",
+    "OBJDUMP",
+]

ci/docker/aarch64-unknown-linux-gnu/Dockerfile

@@ -1,13 +1,28 @@
 FROM ubuntu:17.10
-RUN apt-get update && apt-get install -y --no-install-recommends \
-  gcc \
-  ca-certificates \
-  libc6-dev \
-  gcc-aarch64-linux-gnu \
-  libc6-dev-arm64-cross \
-  qemu-user \
-  make \
-  file
+
+RUN apt-get update -y && apt-get install -y --no-install-recommends \
+      bc \
+      bzip2 \
+      ca-certificates \
+      cmake \
+      cpio \
+      curl \
+      file \
+      g++ \
+      gcc-aarch64-linux-gnu \
+      git \
+      libc6-dev \
+      libc6-dev-arm64-cross \
+      make \
+      python2.7 \
+      qemu-system-aarch64 \
+      xz-utils
+
+COPY linux-aarch64.sh /
+RUN bash /linux-aarch64.sh
+
+COPY test-runner-linux /
+
 ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc \
-    CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUNNER="qemu-aarch64 -L /usr/aarch64-linux-gnu" \
-    OBJDUMP=aarch64-linux-gnu-objdump
+    CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUNNER="/test-runner-linux" \
+    OBJDUMP=aarch64-linux-gnu-objdump

ci/docker/aarch64-unknown-linux-gnu/linux-aarch64.sh

@@ -0,0 +1,18 @@
+set -ex
+
+mkdir -m 777 /qemu
+cd /qemu
+
+curl -LO https://github.com/qemu/qemu/raw/master/pc-bios/efi-virtio.rom
+curl -LO http://ftp.debian.org/debian/dists/testing/main/installer-arm64/20170828/images/netboot/debian-installer/arm64/linux
+curl -LO http://ftp.debian.org/debian/dists/testing/main/installer-arm64/20170828/images/netboot/debian-installer/arm64/initrd.gz
+
+mv linux kernel
+#mv initrd.debian initrd.gz
+
+mkdir init
+cd init
+gunzip -c ../initrd.gz | cpio -id
+rm ../initrd.gz
+cp /usr/aarch64-linux-gnu/lib/libgcc_s.so.1 usr/lib/
+chmod a+w .

ci/docker/aarch64-unknown-linux-gnu/test-runner-linux

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+set -e
+
+cd /qemu/init
+echo "arg is: ${1}"
+cp -f $1 prog
+find . | cpio --create --format='newc' --quiet | gzip > ../initrd.gz
+cd ..
+
+mkdir bin
+cp $OBJDUMP bin/
+
+timeout 60s qemu-system-aarch64 \
+  -m 1024 \
+  -smp 1 \
+  -machine virt \
+  -cpu cortex-a57 \
+  -nographic \
+  -kernel kernel \
+  -initrd initrd.gz \
+  --append "console=ttyAMA0" \
+  -fsdev local,id=r,path=/qemu/bin,security_model=none \
+  -device virtio-9p-device,fsdev=r,mount_tag=r \
+  -append init="mount -t 9p -o trans=virtio r /mnt && export PATH=/mnt/bin:$PATH && /prog ${@:2}" > output 2>&1 || true
+
+# remove kernel messages
+tr -d '\r' < output | egrep -v '^\['
+
+! grep FAILED output > /dev/null

ci/run-docker.sh

@@ -4,10 +4,11 @@
 set -ex
 
 run() {
-    echo $1
+    echo "Building docker container for TARGET=${1}"
     docker build -t stdsimd ci/docker/$1
     mkdir -p target
     target=$(echo $1 | sed 's/-emulated//')
+    echo "Running docker"
     docker run \
       --user `id -u`:`id -g` \
       --rm \

ci/run.sh

@@ -19,6 +19,7 @@ FEATURES="strict,$FEATURES"
 
 echo "RUSTFLAGS=${RUSTFLAGS}"
 echo "FEATURES=${FEATURES}"
+echo "OBJDUMP=${OBJDUMP}"
 
-cargo test --target $TARGET --features $FEATURES
-cargo test --release --target $TARGET --features $FEATURES
+cargo test --target $TARGET --features $FEATURES --verbose -- --nocapture
+cargo test --release --target $TARGET --features $FEATURES --verbose -- --nocapture

src/arm/runtime/mod.rs

@@ -0,0 +1,2 @@
+
+

src/lib.rs

@@ -153,8 +153,13 @@ pub mod vendor {
 
     #[cfg(target_arch = "aarch64")]
     pub use aarch64::*;
+
+    pub use runtime::{__unstable_detect_feature, __Feature};
 }
 
+#[macro_use]
+mod runtime;
+
 #[macro_use]
 mod macros;
 mod simd_llvm;
@@ -164,7 +169,6 @@ mod v512;
 mod v64;
 
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-#[macro_use]
 mod x86;
 
 #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]

src/macros.rs

@@ -272,52 +272,3 @@ macro_rules! define_casts {
         )+
     }
 }
-
-/// Is a feature supported by the host CPU?
-///
-/// This macro performs run-time feature detection. It returns true if the host
-/// CPU in which the binary is running on supports a particular feature.
-#[macro_export]
-macro_rules! cfg_feature_enabled {
-    ($name:tt) => (
-        {
-            #[cfg(target_feature = $name)]
-            {
-                true
-            }
-            #[cfg(not(target_feature = $name))]
-            {
-                __unstable_detect_feature!($name)
-            }
-        }
-    )
-}
-
-/// On ARM features are only detected at compile-time using
-/// cfg(target_feature), so if this macro is executed the
-/// feature is not supported.
-#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! __unstable_detect_feature {
-    ("neon") => { false };
-    ($t:tt) => { compile_error!(concat!("unknown target feature: ", $t)) };
-}
-
-/// In all unsupported architectures using the macro is an error
-#[cfg(not(any(target_arch = "x86", target_arch = "x86_64",
-              target_arch = "arm", target_arch = "aarch64")))]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! __unstable_detect_feature {
-    ($t:tt) => { compile_error!(concat!("unknown target feature: ", $t)) };
-}
-
-#[cfg(test)]
-mod tests {
-    #[cfg(target_arch = "x86_64")]
-    #[test]
-    fn test_macros() {
-        assert!(cfg_feature_enabled!("sse"));
-    }
-}

src/runtime/aarch64.rs

@@ -0,0 +1,56 @@
+//! Run-time feature detection on ARM Aarch64.
+use super::{bit, linux};
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __unstable_detect_feature {
+    ("neon") => {
+        // FIXME: this should be removed once we rename Aarch64 neon to asimd
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::asimd{})
+    };
+    ("asimd") => {
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::asimd{})
+    };
+    ("pmull") => {
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::pmull{})
+    };
+    ($t:tt) => { compile_error!(concat!("unknown arm target feature: ", $t)) };
+}
+
+/// ARM 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 {
+    /// ARM Advanced SIMD (ASIMD) - Aarch64
+    asimd,
+    /// Polynomial Multiply
+    pmull,
+}
+
+pub fn detect_features<T: linux::FeatureQuery>(mut x: T) -> usize {
+    let value: usize = 0;
+    {
+        let mut enable_feature = | f | {
+            if x.has_feature(& f) {
+                bit::set(value, f as u32);
+            }
+        };
+        enable_feature(__Feature::asimd);
+        enable_feature(__Feature::pmull);
+    }
+    value
+}
+
+impl linux::FeatureQuery for linux::CpuInfo {
+    fn has_feature(&mut self, x: &__Feature) -> bool {
+        use self::__Feature::*;
+        match *x {
+            asimd => self.field("Features").has("asimd"),
+            pmull => self.field("Features").has("pmull"),
+        }
+    }
+}

src/runtime/arm.rs

@@ -0,0 +1,64 @@
+//! Run-time feature detection on ARM Aarch32.
+
+use super::{bit, linux};
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __unstable_detect_feature {
+    ("neon") => {
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::neon{})
+    };
+    ("pmull") => {
+        $crate::vendor::__unstable_detect_feature($crate::vendor::__Feature::pmull{})
+    };
+    ($t:tt) => { compile_error!(concat!("unknown arm target feature: ", $t)) };
+}
+
+/// ARM 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 {
+    /// ARM Advanced SIMD (NEON) - Aarch32
+    neon,
+    /// Polynomial Multiply
+    pmull,
+}
+
+pub fn detect_features<T: linux::FeatureQuery>(mut x: T) -> usize {
+    let value: usize = 0;
+    {
+        let mut enable_feature = | f | {
+            if x.has_feature(&f) {
+                bit::set(value, f as u32);
+            }
+        };
+        enable_feature(__Feature::neon);
+        enable_feature(__Feature::pmull);
+    }
+    value
+}
+
+/// Is the CPU known to have a broken NEON unit?
+///
+/// See https://crbug.com/341598.
+fn has_broken_neon(cpuinfo: & linux::CpuInfo) -> bool {
+    cpuinfo.field("CPU implementer") == "0x51"
+        && cpuinfo.field("CPU architecture") == "7"
+        && cpuinfo.field("CPU variant") == "0x1"
+        && cpuinfo.field("CPU part") == "0x04d"
+        && cpuinfo.field("CPU revision") == "0"
+}
+
+impl linux::FeatureQuery for linux::CpuInfo {
+    fn has_feature(&mut self, x: &__Feature) -> bool {
+        use self::__Feature::*;
+        match *x {
+            neon => self.field("Features").has("neon") && !has_broken_neon(self),
+            pmull => self.field("Features").has("pmull"),
+        }
+    }
+}

src/runtime/bit.rs

@@ -0,0 +1,11 @@
+//! Bit manipulation utilities
+
+/// Sets the `bit` of `x`.
+pub const fn set(x: usize, bit: u32) -> usize {
+    x | 1 << bit
+}
+
+/// Tests the `bit` of `x`.
+pub const fn test(x: usize, bit: u32) -> bool {
+    x & (1 << bit) != 0
+}

src/runtime/cache.rs

@@ -0,0 +1,29 @@
+//! Cache of run-time feature detection
+
+use super::bit;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+/// This global variable is a bitset used to cache the features supported by
+/// the
+/// CPU.
+static CACHE: AtomicUsize = AtomicUsize::new(::std::usize::MAX);
+
+/// Test the `bit` of the storage. If the storage has not been initialized,
+/// initializes it with the result of `f()`.
+///
+/// On its first invocation, it detects the CPU features and caches them in the
+/// `FEATURES` global variable as an `AtomicUsize`.
+///
+/// It uses the `__Feature` variant to index into this variable as a bitset. If
+/// the bit is set, the feature is enabled, and otherwise it is disabled.
+///
+/// PLEASE: do not use this, it is an implementation detail subject to change.
+pub fn test<F>(bit: u32, f: F) -> bool
+where
+    F: FnOnce() -> usize,
+{
+    if CACHE.load(Ordering::Relaxed) == ::std::usize::MAX {
+        CACHE.store(f(), Ordering::Relaxed);
+    }
+    bit::test(CACHE.load(Ordering::Relaxed), bit)
+}