Replace uses of std with libc

Author: Amanieu

Diff for: crates/std_detect/src/detect/cache.rs

@@ -3,9 +3,9 @@
 
 #![allow(dead_code)] // not used on all platforms
 
-use crate::sync::atomic::Ordering;
+use core::sync::atomic::Ordering;
 
-use crate::sync::atomic::AtomicUsize;
+use core::sync::atomic::AtomicUsize;
 
 /// Sets the `bit` of `x`.
 #[inline]

Diff for: crates/std_detect/src/detect/mod.rs

@@ -140,7 +140,7 @@ pub fn features() -> impl Iterator<Item = (&'static str, bool)> {
             target_arch = "mips64",
         ))] {
             (0_u8..Feature::_last as u8).map(|discriminant: u8| {
-                let f: Feature = unsafe { crate::mem::transmute(discriminant) };
+                let f: Feature = unsafe { core::mem::transmute(discriminant) };
                 let name: &'static str = f.to_str();
                 let enabled: bool = check_for(f);
                 (name, enabled)

Diff for: crates/std_detect/src/detect/os/freebsd/auxvec.rs

@@ -42,7 +42,7 @@ pub(crate) fn auxv() -> Result<AuxVec, ()> {
 
 /// Tries to read the `key` from the auxiliary vector.
 fn archauxv(key: usize) -> Result<usize, ()> {
-    use crate::mem;
+    use core::mem;
 
     #[derive(Copy, Clone)]
     #[repr(C)]

Diff for: crates/std_detect/src/detect/os/linux/auxvec.rs

@@ -1,9 +1,6 @@
 //! Parses ELF auxiliary vectors.
 #![cfg_attr(not(target_arch = "aarch64"), allow(dead_code))]
 
-#[cfg(feature = "std_detect_file_io")]
-use crate::{fs::File, io::Read};
-
 /// Key to access the CPU Hardware capabilities bitfield.
 pub(crate) const AT_HWCAP: usize = 16;
 /// Key to access the CPU Hardware capabilities 2 bitfield.
@@ -139,7 +136,7 @@ fn getauxval(key: usize) -> Result<usize, ()> {
             return Err(());
         }
 
-        let ffi_getauxval: F = crate::mem::transmute(ptr);
+        let ffi_getauxval: F = core::mem::transmute(ptr);
         Ok(ffi_getauxval(key))
     }
 }
@@ -148,19 +145,19 @@ fn getauxval(key: usize) -> Result<usize, ()> {
 /// function returns `Err`.
 #[cfg(feature = "std_detect_file_io")]
 fn auxv_from_file(file: &str) -> Result<AuxVec, ()> {
-    let mut file = File::open(file).map_err(|_| ())?;
+    let file = super::read_file(file)?;
 
     // See <https://github.com/torvalds/linux/blob/v3.19/include/uapi/linux/auxvec.h>.
     //
     // The auxiliary vector contains at most 32 (key,value) fields: from
     // `AT_EXECFN = 31` to `AT_NULL = 0`. That is, a buffer of
     // 2*32 `usize` elements is enough to read the whole vector.
     let mut buf = [0_usize; 64];
-    {
-        let raw: &mut [u8; 64 * crate::mem::size_of::<usize>()] =
-            unsafe { crate::mem::transmute(&mut buf) };
-        file.read(raw).map_err(|_| ())?;
+    let len = core::mem::size_of_val(&buf).max(file.len());
+    unsafe {
+        core::ptr::copy_nonoverlapping(file.as_ptr(), buf.as_mut_ptr() as *mut u8, len);
     }
+
     auxv_from_buf(&buf)
 }
 

Diff for: crates/std_detect/src/detect/os/linux/cpuinfo.rs

@@ -1,8 +1,7 @@
 //! Parses /proc/cpuinfo
 #![cfg_attr(not(target_arch = "arm"), allow(dead_code))]
 
-extern crate std;
-use self::std::{fs::File, io, io::Read, prelude::v1::*};
+use alloc::string::String;
 
 /// cpuinfo
 pub(crate) struct CpuInfo {
@@ -11,11 +10,11 @@ pub(crate) struct CpuInfo {
 
 impl CpuInfo {
     /// Reads /proc/cpuinfo into CpuInfo.
-    pub(crate) fn new() -> Result<Self, io::Error> {
-        let mut file = File::open("/proc/cpuinfo")?;
-        let mut cpui = Self { raw: String::new() };
-        file.read_to_string(&mut cpui.raw)?;
-        Ok(cpui)
+    pub(crate) fn new() -> Result<Self, ()> {
+        let raw = super::read_file("/proc/cpuinfo")?;
+        Ok(Self {
+            raw: String::from_utf8(raw).map_err(|_| ())?,
+        })
     }
     /// Returns the value of the cpuinfo `field`.
     pub(crate) fn field(&self, field: &str) -> CpuInfoField {
@@ -34,7 +33,7 @@ impl CpuInfo {
     }
 
     #[cfg(test)]
-    fn from_str(other: &str) -> Result<Self, ::std::io::Error> {
+    fn from_str(other: &str) -> Result<Self, ()> {
         Ok(Self {
             raw: String::from(other),
         })

Diff for: crates/std_detect/src/detect/os/linux/mod.rs

@@ -1,10 +1,43 @@
 //! Run-time feature detection on Linux
+//!
+#[cfg(feature = "std_detect_file_io")]
+use alloc::vec::Vec;
 
 mod auxvec;
 
 #[cfg(feature = "std_detect_file_io")]
 mod cpuinfo;
 
+#[cfg(feature = "std_detect_file_io")]
+fn read_file(path: &str) -> Result<Vec<u8>, ()> {
+    let mut path = Vec::from(path.as_bytes());
+    path.push(0);
+
+    unsafe {
+        let file = libc::open(path.as_ptr() as *const libc::c_char, libc::O_RDONLY);
+        if file == -1 {
+            return Err(());
+        }
+
+        let mut data = Vec::new();
+        loop {
+            data.reserve(4096);
+            let spare = data.spare_capacity_mut();
+            match libc::read(file, spare.as_mut_ptr() as *mut _, spare.len()) {
+                -1 => {
+                    libc::close(file);
+                    return Err(());
+                }
+                0 => break,
+                n => data.set_len(data.len() + n as usize),
+            }
+        }
+
+        libc::close(file);
+        Ok(data)
+    }
+}
+
 cfg_if::cfg_if! {
     if #[cfg(target_arch = "aarch64")] {
         mod aarch64;

Diff for: crates/std_detect/src/detect/os/x86.rs

@@ -1,11 +1,11 @@
 //! x86 run-time feature detection is OS independent.
 
 #[cfg(target_arch = "x86")]
-use crate::arch::x86::*;
+use core::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
-use crate::arch::x86_64::*;
+use core::arch::x86_64::*;
 
-use crate::mem;
+use core::mem;
 
 use crate::detect::{bit, cache, Feature};
 

Diff for: crates/std_detect/src/lib.rs

@@ -15,30 +15,17 @@
 #![feature(const_fn, staged_api, stdsimd, doc_cfg, allow_internal_unstable)]
 #![allow(clippy::shadow_reuse)]
 #![deny(clippy::missing_inline_in_public_items)]
-#![cfg_attr(target_os = "linux", feature(linkage))]
 #![cfg_attr(all(target_os = "freebsd", target_arch = "aarch64"), feature(llvm_asm))]
 #![cfg_attr(test, allow(unused_imports))]
+#![cfg_attr(feature = "std_detect_file_io", feature(vec_spare_capacity))]
 #![no_std]
 
-cfg_if::cfg_if! {
-    if #[cfg(feature = "std_detect_file_io")] {
-        #[cfg_attr(test, macro_use(println))]
-        extern crate std;
+#[cfg(feature = "std_detect_file_io")]
+extern crate alloc;
 
-        #[allow(unused_imports)]
-        use std::{arch, env, fs, io, mem, sync};
-    } else {
-        #[cfg(test)]
-        #[macro_use(println)]
-        extern crate std;
-
-        #[allow(unused_imports)]
-        use core::{arch, mem, sync};
-    }
-}
-
-#[cfg(feature = "std_detect_dlsym_getauxval")]
-extern crate libc;
+#[cfg(test)]
+#[macro_use]
+extern crate std;
 
 #[doc(hidden)]
 #[unstable(feature = "stdsimd", issue = "27731")]