c_void -> *mut u8

gnzlbg · gnzlbg · commit 1fabed52ac71 · 2017-11-22T10:49:05.000+01:00
diff --git a/coresimd/src/runtime/x86.rs b/coresimd/src/runtime/x86.rs
@@ -364,8 +364,7 @@ pub fn detect_features() -> usize {
                 enable(extended_features_ebx, 5, __Feature::avx2);
 
                 // For AVX-512 the OS also needs to support saving/restoring
-                // the extended state, only then we enable
-                // AVX-512 support:
+                // the extended state, only then we enable AVX-512 support:
                 if os_avx512_support {
                     enable(extended_features_ebx, 16, __Feature::avx512f);
                     enable(extended_features_ebx, 17, __Feature::avx512dq);
@@ -384,8 +383,8 @@ pub fn detect_features() -> usize {
                 }
             }
 
-            // Processor Extended State Enumeration Sub-leaf (EAX = 0DH, ECX =
-            // 1)
+            // Processor Extended State Enumeration Sub-leaf
+            // (EAX = 0DH, ECX = 1)
             if max_basic_leaf >= 0xd {
                 let CpuidResult {
                     eax: proc_extended_state1_eax,
@@ -417,7 +416,6 @@ pub fn detect_features() -> usize {
 
 #[cfg(test)]
 mod tests {
-    #[cfg(feature = "std")]
     #[test]
     fn runtime_detection_x86_nocapture() {
         println!("sse: {:?}", cfg_feature_enabled!("sse"));
diff --git a/coresimd/src/x86/i586/sse.rs b/coresimd/src/x86/i586/sse.rs
@@ -6,7 +6,6 @@ use core::ptr;
 use simd_llvm::simd_shuffle4;
 use v128::*;
 use v64::f32x2;
-use x86::c_void;
 
 #[cfg(test)]
 use stdsimd_test::assert_instr;
@@ -1572,7 +1571,7 @@ pub const _MM_HINT_NTA: i8 = 0;
 #[cfg_attr(test, assert_instr(prefetcht1, strategy = _MM_HINT_T1))]
 #[cfg_attr(test, assert_instr(prefetcht2, strategy = _MM_HINT_T2))]
 #[cfg_attr(test, assert_instr(prefetchnta, strategy = _MM_HINT_NTA))]
-pub unsafe fn _mm_prefetch(p: *const c_void, strategy: i8) {
+pub unsafe fn _mm_prefetch(p: *const u8, strategy: i8) {
     // The `strategy` must be a compile-time constant, so we use a short form
     // of `constify_imm8!` for now.
     // We use the `llvm.prefetch` instrinsic with `rw` = 0 (read), and
@@ -1684,7 +1683,7 @@ extern "C" {
     #[link_name = "llvm.x86.sse.ldmxcsr"]
     fn ldmxcsr(p: *const i8);
     #[link_name = "llvm.prefetch"]
-    fn prefetch(p: *const c_void, rw: i32, loc: i32, ty: i32);
+    fn prefetch(p: *const u8, rw: i32, loc: i32, ty: i32);
     #[link_name = "llvm.x86.sse.cmp.ss"]
     fn cmpss(a: f32x4, b: f32x4, imm8: i8) -> f32x4;
 }
diff --git a/coresimd/src/x86/i586/sse2.rs b/coresimd/src/x86/i586/sse2.rs
@@ -8,7 +8,6 @@ use core::ptr;
 
 use simd_llvm::{simd_cast, simd_shuffle16, simd_shuffle2, simd_shuffle4,
                 simd_shuffle8};
-use x86::c_void;
 use x86::__m128i;
 use v128::*;
 use v64::*;
@@ -29,7 +28,7 @@ pub unsafe fn _mm_pause() {
 #[inline(always)]
 #[target_feature = "+sse2"]
 #[cfg_attr(test, assert_instr(clflush))]
-pub unsafe fn _mm_clflush(p: *mut c_void) {
+pub unsafe fn _mm_clflush(p: *mut u8) {
     clflush(p)
 }
 
@@ -1989,7 +1988,7 @@ extern "C" {
     #[link_name = "llvm.x86.sse2.pause"]
     fn pause();
     #[link_name = "llvm.x86.sse2.clflush"]
-    fn clflush(p: *mut c_void);
+    fn clflush(p: *mut u8);
     #[link_name = "llvm.x86.sse2.lfence"]
     fn lfence();
     #[link_name = "llvm.x86.sse2.mfence"]
@@ -2142,7 +2141,6 @@ extern "C" {
 
 #[cfg(test)]
 mod tests {
-    use super::c_void;
     use stdsimd_test::simd_test;
     use test::black_box; // Used to inhibit constant-folding.
 
@@ -2158,7 +2156,7 @@ mod tests {
     #[simd_test = "sse2"]
     unsafe fn _mm_clflush() {
         let x = 0;
-        sse2::_mm_clflush(&x as *const _ as *mut c_void);
+        sse2::_mm_clflush(&x as *const _ as *mut u8);
     }
 
     #[simd_test = "sse2"]
diff --git a/coresimd/src/x86/i586/xsave.rs b/coresimd/src/x86/i586/xsave.rs
@@ -5,22 +5,20 @@
 #[cfg(test)]
 use stdsimd_test::assert_instr;
 
-use x86::c_void;
-
 #[allow(improper_ctypes)]
 extern "C" {
     #[link_name = "llvm.x86.xsave"]
     fn xsave(p: *mut i8, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xrstor"]
-    fn xrstor(p: *const c_void, hi: i32, lo: i32) -> ();
+    fn xrstor(p: *const u8, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xsetbv"]
     fn xsetbv(v: i32, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xgetbv"]
     fn xgetbv(x: i32) -> i64;
     #[link_name = "llvm.x86.xsave64"]
     fn xsave64(p: *mut i8, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xrstor64"]
-    fn xrstor64(p: *const c_void, hi: i32, lo: i32) -> ();
+    fn xrstor64(p: *const u8, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xsaveopt"]
     fn xsaveopt(p: *mut i8, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xsaveopt64"]
@@ -34,9 +32,9 @@ extern "C" {
     #[link_name = "llvm.x86.xsaves64"]
     fn xsaves64(p: *mut i8, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xrstors"]
-    fn xrstors(p: *const c_void, hi: i32, lo: i32) -> ();
+    fn xrstors(p: *const u8, hi: i32, lo: i32) -> ();
     #[link_name = "llvm.x86.xrstors64"]
-    fn xrstors64(p: *const c_void, hi: i32, lo: i32) -> ();
+    fn xrstors64(p: *const u8, hi: i32, lo: i32) -> ();
 }
 
 /// Perform a full or partial save of the enabled processor states to memory at
@@ -50,7 +48,7 @@ extern "C" {
 #[inline(always)]
 #[target_feature = "+xsave"]
 #[cfg_attr(test, assert_instr(xsave))]
-pub unsafe fn _xsave(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsave(mem_addr: *mut u8, save_mask: u64) -> () {
     xsave(mem_addr as *mut i8, (save_mask >> 32) as i32, save_mask as i32);
 }
 
@@ -63,7 +61,7 @@ pub unsafe fn _xsave(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[inline(always)]
 #[target_feature = "+xsave"]
 #[cfg_attr(test, assert_instr(xrstor))]
-pub unsafe fn _xrstor(mem_addr: *const c_void, rs_mask: u64) -> () {
+pub unsafe fn _xrstor(mem_addr: *const u8, rs_mask: u64) -> () {
     xrstor(mem_addr, (rs_mask >> 32) as i32, rs_mask as i32);
 }
 
@@ -104,7 +102,7 @@ pub unsafe fn _xgetbv(xcr_no: u32) -> u64 {
 #[target_feature = "+xsave"]
 #[cfg_attr(test, assert_instr(xsave64))]
 #[cfg(not(target_arch = "x86"))]
-pub unsafe fn _xsave64(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsave64(mem_addr: *mut u8, save_mask: u64) -> () {
     xsave64(mem_addr as *mut i8, (save_mask >> 32) as i32, save_mask as i32);
 }
 
@@ -118,7 +116,7 @@ pub unsafe fn _xsave64(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[target_feature = "+xsave"]
 #[cfg_attr(test, assert_instr(xrstor64))]
 #[cfg(not(target_arch = "x86"))]
-pub unsafe fn _xrstor64(mem_addr: *const c_void, rs_mask: u64) -> () {
+pub unsafe fn _xrstor64(mem_addr: *const u8, rs_mask: u64) -> () {
     xrstor64(mem_addr, (rs_mask >> 32) as i32, rs_mask as i32);
 }
 
@@ -132,7 +130,7 @@ pub unsafe fn _xrstor64(mem_addr: *const c_void, rs_mask: u64) -> () {
 #[inline(always)]
 #[target_feature = "+xsave,+xsaveopt"]
 #[cfg_attr(test, assert_instr(xsaveopt))]
-pub unsafe fn _xsaveopt(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsaveopt(mem_addr: *mut u8, save_mask: u64) -> () {
     xsaveopt(mem_addr as *mut i8, (save_mask >> 32) as i32, save_mask as i32);
 }
 
@@ -147,7 +145,7 @@ pub unsafe fn _xsaveopt(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[target_feature = "+xsave,+xsaveopt"]
 #[cfg_attr(test, assert_instr(xsaveopt64))]
 #[cfg(not(target_arch = "x86"))]
-pub unsafe fn _xsaveopt64(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsaveopt64(mem_addr: *mut u8, save_mask: u64) -> () {
     xsaveopt64(
         mem_addr as *mut i8,
         (save_mask >> 32) as i32,
@@ -164,7 +162,7 @@ pub unsafe fn _xsaveopt64(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[inline(always)]
 #[target_feature = "+xsave,+xsavec"]
 #[cfg_attr(test, assert_instr(xsavec))]
-pub unsafe fn _xsavec(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsavec(mem_addr: *mut u8, save_mask: u64) -> () {
     xsavec(mem_addr as *mut i8, (save_mask >> 32) as i32, save_mask as i32);
 }
 
@@ -178,7 +176,7 @@ pub unsafe fn _xsavec(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[target_feature = "+xsave,+xsavec"]
 #[cfg_attr(test, assert_instr(xsavec64))]
 #[cfg(not(target_arch = "x86"))]
-pub unsafe fn _xsavec64(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsavec64(mem_addr: *mut u8, save_mask: u64) -> () {
     xsavec64(mem_addr as *mut i8, (save_mask >> 32) as i32, save_mask as i32);
 }
 
@@ -192,7 +190,7 @@ pub unsafe fn _xsavec64(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[inline(always)]
 #[target_feature = "+xsave,+xsaves"]
 #[cfg_attr(test, assert_instr(xsaves))]
-pub unsafe fn _xsaves(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsaves(mem_addr: *mut u8, save_mask: u64) -> () {
     xsaves(mem_addr as *mut i8, (save_mask >> 32) as i32, save_mask as i32);
 }
 
@@ -207,7 +205,7 @@ pub unsafe fn _xsaves(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[target_feature = "+xsave,+xsaves"]
 #[cfg_attr(test, assert_instr(xsaves64))]
 #[cfg(not(target_arch = "x86"))]
-pub unsafe fn _xsaves64(mem_addr: *mut c_void, save_mask: u64) -> () {
+pub unsafe fn _xsaves64(mem_addr: *mut u8, save_mask: u64) -> () {
     xsaves64(mem_addr as *mut i8, (save_mask >> 32) as i32, save_mask as i32);
 }
 
@@ -223,7 +221,7 @@ pub unsafe fn _xsaves64(mem_addr: *mut c_void, save_mask: u64) -> () {
 #[inline(always)]
 #[target_feature = "+xsave,+xsaves"]
 #[cfg_attr(test, assert_instr(xrstors))]
-pub unsafe fn _xrstors(mem_addr: *const c_void, rs_mask: u64) -> () {
+pub unsafe fn _xrstors(mem_addr: *const u8, rs_mask: u64) -> () {
     xrstors(mem_addr, (rs_mask >> 32) as i32, rs_mask as i32);
 }
 
@@ -240,13 +238,12 @@ pub unsafe fn _xrstors(mem_addr: *const c_void, rs_mask: u64) -> () {
 #[target_feature = "+xsave,+xsaves"]
 #[cfg_attr(test, assert_instr(xrstors64))]
 #[cfg(not(target_arch = "x86"))]
-pub unsafe fn _xrstors64(mem_addr: *const c_void, rs_mask: u64) -> () {
+pub unsafe fn _xrstors64(mem_addr: *const u8, rs_mask: u64) -> () {
     xrstors64(mem_addr, (rs_mask >> 32) as i32, rs_mask as i32);
 }
 
 #[cfg(test)]
 mod tests {
-    use x86::c_void;
     use x86::i586::xsave;
     use stdsimd_test::simd_test;
     use std::fmt;
@@ -260,8 +257,8 @@ mod tests {
         fn new() -> Buffer {
             Buffer { data: [0; 1024] }
         }
-        fn ptr(&mut self) -> *mut c_void {
-            &mut self.data[0] as *mut _ as *mut c_void
+        fn ptr(&mut self) -> *mut u8 {
+            &mut self.data[0] as *mut _ as *mut u8
         }
     }
 
diff --git a/coresimd/src/x86/mod.rs b/coresimd/src/x86/mod.rs
@@ -32,17 +32,3 @@ pub type __m128i = ::v128::i8x16;
 /// 256-bit wide signed integer vector type
 #[allow(non_camel_case_types)]
 pub type __m256i = ::v256::i8x32;
-
-
-/// `C`'s `void` type.
-#[cfg(not(feature = "std"))]
-#[allow(non_camel_case_types)]
-#[repr(u8)]
-pub enum c_void {
-    #[doc(hidden)] __variant1,
-    #[doc(hidden)] __variant2,
-}
-
-// FIXME: we should not depend on std for this
-#[cfg(feature = "std")]
-use std::os::raw::c_void;
