Fix compiler-builtins runtime symbols definitions

Author: Urgau

library/compiler-builtins/compiler-builtins/src/arm.rs

@@ -84,7 +84,11 @@ intrinsics! {
     ///
     /// Usual `memcpy` requirements apply.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memcpy(dst: *mut u8, src: *const u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memcpy(
+        dst: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) {
         // SAFETY: memcpy preconditions apply.
         unsafe { crate::mem::memcpy(dst, src, n) };
     }
@@ -96,7 +100,11 @@ intrinsics! {
     /// Usual `memcpy` requirements apply. Additionally, `dest` and `src` must be aligned to
     /// four bytes.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memcpy4(dst: *mut u8, src: *const u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memcpy4(
+        dst: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) {
         // We are guaranteed 4-alignment, so accessing at u32 is okay.
         let mut dst = dst.cast::<u32>();
         let mut src = src.cast::<u32>();
@@ -121,7 +129,7 @@ intrinsics! {
         }
 
         // SAFETY: `dst` and `src` will still be valid for `n` bytes
-        unsafe { __aeabi_memcpy(dst.cast::<u8>(), src.cast::<u8>(), n) };
+        unsafe { __aeabi_memcpy(dst.cast::<core::ffi::c_void>(), src.cast::<core::ffi::c_void>(), n) };
     }
 
     /// `memcpy` for 8-byte alignment.
@@ -131,7 +139,11 @@ intrinsics! {
     /// Usual `memcpy` requirements apply. Additionally, `dest` and `src` must be aligned to
     /// eight bytes.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memcpy8(dst: *mut u8, src: *const u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memcpy8(
+        dst: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) {
         debug_assert!(dst.addr().is_multiple_of(8));
         debug_assert!(src.addr().is_multiple_of(8));
 
@@ -145,7 +157,11 @@ intrinsics! {
     ///
     /// Usual `memmove` requirements apply.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memmove(dst: *mut u8, src: *const u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memmove(
+        dst: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) {
         // SAFETY: memmove preconditions apply.
         unsafe { crate::mem::memmove(dst, src, n) };
     }
@@ -157,7 +173,11 @@ intrinsics! {
     /// Usual `memmove` requirements apply. Additionally, `dest` and `src` must be aligned to
     /// four bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
-    pub unsafe extern "aapcs" fn __aeabi_memmove4(dst: *mut u8, src: *const u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memmove4(
+        dst: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) {
         debug_assert!(dst.addr().is_multiple_of(4));
         debug_assert!(src.addr().is_multiple_of(4));
 
@@ -172,7 +192,11 @@ intrinsics! {
     /// Usual `memmove` requirements apply. Additionally, `dst` and `src` must be aligned to
     /// eight bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
-    pub unsafe extern "aapcs" fn __aeabi_memmove8(dst: *mut u8, src: *const u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memmove8(
+        dst: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) {
         debug_assert!(dst.addr().is_multiple_of(8));
         debug_assert!(src.addr().is_multiple_of(8));
 
@@ -186,7 +210,11 @@ intrinsics! {
     ///
     /// Usual `memset` requirements apply.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memset(dst: *mut u8, n: usize, c: i32) {
+    pub unsafe extern "aapcs" fn __aeabi_memset(
+        dst: *mut core::ffi::c_void,
+        n: usize,
+        c: i32
+    ) {
         // Note the different argument order
         // SAFETY: memset preconditions apply.
         unsafe { crate::mem::memset(dst, c, n) };
@@ -199,7 +227,11 @@ intrinsics! {
     /// Usual `memset` requirements apply. Additionally, `dest` and `src` must be aligned to
     /// four bytes.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memset4(dst: *mut u8, n: usize, c: i32) {
+    pub unsafe extern "aapcs" fn __aeabi_memset4(
+        dst: *mut core::ffi::c_void,
+        n: usize,
+        c: i32
+    ) {
         let mut dst = dst.cast::<u32>();
         debug_assert!(dst.is_aligned());
         let mut n = n;
@@ -222,7 +254,7 @@ intrinsics! {
         }
 
         // SAFETY: `dst` will still be valid for `n` bytes
-        unsafe { __aeabi_memset(dst.cast::<u8>(), n, byte as i32) };
+        unsafe { __aeabi_memset(dst.cast::<core::ffi::c_void>(), n, byte as i32) };
     }
 
     /// `memset` for 8-byte alignment.
@@ -232,7 +264,11 @@ intrinsics! {
     /// Usual `memset` requirements apply. Additionally, `dst` and `src` must be aligned to
     /// eight bytes.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memset8(dst: *mut u8, n: usize, c: i32) {
+    pub unsafe extern "aapcs" fn __aeabi_memset8(
+        dst: *mut core::ffi::c_void,
+        n: usize,
+        c: i32
+    ) {
         debug_assert!(dst.addr().is_multiple_of(8));
 
         // SAFETY: memset preconditions apply, less strict alignment.
@@ -245,7 +281,7 @@ intrinsics! {
     ///
     /// Usual `memclr` requirements apply.
     #[cfg(not(target_vendor = "apple"))]
-    pub unsafe extern "aapcs" fn __aeabi_memclr(dst: *mut u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memclr(dst: *mut core::ffi::c_void, n: usize) {
         // SAFETY: memclr preconditions apply, less strict alignment.
         unsafe { __aeabi_memset(dst, n, 0) };
     }
@@ -257,7 +293,7 @@ intrinsics! {
     /// Usual `memclr` requirements apply. Additionally, `dest` and `src` must be aligned to
     /// four bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
-    pub unsafe extern "aapcs" fn __aeabi_memclr4(dst: *mut u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memclr4(dst: *mut core::ffi::c_void, n: usize) {
         debug_assert!(dst.addr().is_multiple_of(4));
 
         // SAFETY: memclr preconditions apply, less strict alignment.
@@ -271,7 +307,7 @@ intrinsics! {
     /// Usual `memclr` requirements apply. Additionally, `dst` and `src` must be aligned to
     /// eight bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
-    pub unsafe extern "aapcs" fn __aeabi_memclr8(dst: *mut u8, n: usize) {
+    pub unsafe extern "aapcs" fn __aeabi_memclr8(dst: *mut core::ffi::c_void, n: usize) {
         debug_assert!(dst.addr().is_multiple_of(8));
 
         // SAFETY: memclr preconditions apply, less strict alignment.

library/compiler-builtins/compiler-builtins/src/mem/mod.rs

@@ -9,37 +9,57 @@ mod impls;
 
 intrinsics! {
     #[mem_builtin]
-    pub unsafe extern "C" fn memcpy(dest: *mut u8, src: *const u8, n: usize) -> *mut u8 {
-        impls::copy_forward(dest, src, n);
+    pub unsafe extern "C" fn memcpy(
+        dest: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) -> *mut core::ffi::c_void {
+        impls::copy_forward(dest.cast(), src.cast(), n);
         dest
     }
 
     #[mem_builtin]
-    pub unsafe extern "C" fn memmove(dest: *mut u8, src: *const u8, n: usize) -> *mut u8 {
+    pub unsafe extern "C" fn memmove(
+        dest: *mut core::ffi::c_void,
+        src: *const core::ffi::c_void,
+        n: usize
+    ) -> *mut core::ffi::c_void {
         let delta = (dest as usize).wrapping_sub(src as usize);
         if delta >= n {
             // We can copy forwards because either dest is far enough ahead of src,
             // or src is ahead of dest (and delta overflowed).
-            impls::copy_forward(dest, src, n);
+            impls::copy_forward(dest.cast(), src.cast(), n);
         } else {
-            impls::copy_backward(dest, src, n);
+            impls::copy_backward(dest.cast(), src.cast(), n);
         }
         dest
     }
 
     #[mem_builtin]
-    pub unsafe extern "C" fn memset(s: *mut u8, c: core::ffi::c_int, n: usize) -> *mut u8 {
-        impls::set_bytes(s, c as u8, n);
+    pub unsafe extern "C" fn memset(
+        s: *mut core::ffi::c_void,
+        c: core::ffi::c_int,
+        n: usize
+    ) -> *mut core::ffi::c_void {
+        impls::set_bytes(s.cast(), c as u8, n);
         s
     }
 
     #[mem_builtin]
-    pub unsafe extern "C" fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> core::ffi::c_int {
-        impls::compare_bytes(s1, s2, n)
+    pub unsafe extern "C" fn memcmp(
+        s1: *const core::ffi::c_void,
+        s2: *const core::ffi::c_void,
+        n: usize
+    ) -> core::ffi::c_int {
+        impls::compare_bytes(s1.cast(), s2.cast(), n)
     }
 
     #[mem_builtin]
-    pub unsafe extern "C" fn bcmp(s1: *const u8, s2: *const u8, n: usize) -> core::ffi::c_int {
+    pub unsafe extern "C" fn bcmp(
+        s1: *const core::ffi::c_void,
+        s2: *const core::ffi::c_void,
+        n: usize
+    ) -> core::ffi::c_int {
         memcmp(s1, s2, n)
     }