From af540c9db270987664540fb072ac9366414306d5 Mon Sep 17 00:00:00 2001
From: danakj <danakj@chromium.org>
Date: Fri, 19 May 2023 15:47:57 -0400
Subject: [PATCH] Add the weak-intrinsics feature

When enabled, the weak-intrinsics feature will cause all intrinsics
functions to be marked with weak linkage (i.e. `#[linkage = "weak"])
so that they can be replaced at link time by a stronger symbol.

This can be set to use C++ intrinsics from the compiler-rt library,
as it will avoid Rust's implementation replacing the compiler-rt
implementation as long as the compiler-rt symbols are linked as
strong symbols. Typically this requires the compiler-rt library to
be explicitly specified in the link command.

Addresses https://github.com/rust-lang/compiler-builtins/issues/525.

Without weak-intrinsics, from nm:
```
00000000 W __aeabi_memclr8  // Is explicitly weak
00000000 T __udivsi3  // Is not.
```

With weak-intrinsics, from nm:
```
00000000 W __aeabi_memclr8  // Is explicitly weak
00000000 W __udivsi3  // Is weak due to weak-intrinsics
```
---
 Cargo.toml     |  11 +++++
 src/arm.rs     |  32 +++++++-------
 src/macros.rs  | 110 ++++++++++++++++++++++++++++++++++++++++++++++++-
 src/mem/mod.rs |  12 +++---
 4 files changed, 141 insertions(+), 24 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9b981283..57b8b34c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -65,6 +65,17 @@ rustc-dep-of-std = ['compiler-builtins', 'core']
 # are not normally public but are required by the `testcrate`
 public-test-deps = []
 
+# Marks all intrinsics functions with weak linkage so that they can be
+# replaced at link time by another implementation. This is particularly useful
+# for mixed Rust/C++ binaries that want to use the C++ intrinsics, otherwise
+# linking against the Rust stdlib will replace those from the compiler-rt
+# library.
+#
+# Unlike the "c" feature, the intrinsics are still provided by the Rust
+# implementations and each will be used unless a stronger symbol replaces
+# it during linking.
+weak-intrinsics = []
+
 [[example]]
 name = "intrinsics"
 required-features = ["compiler-builtins"]
diff --git a/src/arm.rs b/src/arm.rs
index e517a9ef..a062a54e 100644
--- a/src/arm.rs
+++ b/src/arm.rs
@@ -20,9 +20,9 @@ macro_rules! bl {
 intrinsics! {
     // NOTE This function and the ones below are implemented using assembly because they are using a
     // custom calling convention which can't be implemented using a normal Rust function.
+    #[cfg_attr(all(not(windows), not(target_vendor="apple")), weak)]
     #[naked]
     #[cfg(not(target_env = "msvc"))]
-    #[cfg_attr(all(not(windows), not(target_vendor="apple")), linkage = "weak")]
     pub unsafe extern "C" fn __aeabi_uidivmod() {
         core::arch::asm!(
             "push {{lr}}",
@@ -36,8 +36,8 @@ intrinsics! {
         );
     }
 
+    #[cfg_attr(all(not(windows), not(target_vendor="apple")), weak)]
     #[naked]
-    #[cfg_attr(all(not(windows), not(target_vendor="apple")), linkage = "weak")]
     pub unsafe extern "C" fn __aeabi_uldivmod() {
         core::arch::asm!(
             "push {{r4, lr}}",
@@ -53,8 +53,8 @@ intrinsics! {
         );
     }
 
+    #[cfg_attr(all(not(windows), not(target_vendor="apple")), weak)]
     #[naked]
-    #[cfg_attr(all(not(windows), not(target_vendor="apple")), linkage = "weak")]
     pub unsafe extern "C" fn __aeabi_idivmod() {
         core::arch::asm!(
             "push {{r0, r1, r4, lr}}",
@@ -67,8 +67,8 @@ intrinsics! {
         );
     }
 
+    #[cfg_attr(all(not(windows), not(target_vendor="apple")), weak)]
     #[naked]
-    #[cfg_attr(all(not(windows), not(target_vendor="apple")), linkage = "weak")]
     pub unsafe extern "C" fn __aeabi_ldivmod() {
         core::arch::asm!(
             "push {{r4, lr}}",
@@ -88,14 +88,14 @@ intrinsics! {
     // with custom implementation.
     // FIXME: The `*4` and `*8` variants should be defined as aliases.
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memcpy(dest: *mut u8, src: *const u8, n: usize) {
         ::mem::memcpy(dest, src, n);
     }
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memcpy4(dest: *mut u8, src: *const u8, n: usize) {
         // We are guaranteed 4-alignment, so accessing at u32 is okay.
         let mut dest = dest as *mut u32;
@@ -112,39 +112,39 @@ intrinsics! {
         __aeabi_memcpy(dest as *mut u8, src as *const u8, n);
     }
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memcpy8(dest: *mut u8, src: *const u8, n: usize) {
         __aeabi_memcpy4(dest, src, n);
     }
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memmove(dest: *mut u8, src: *const u8, n: usize) {
         ::mem::memmove(dest, src, n);
     }
 
+    #[weak]
     #[cfg(not(any(target_os = "ios", target_env = "msvc")))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memmove4(dest: *mut u8, src: *const u8, n: usize) {
         __aeabi_memmove(dest, src, n);
     }
 
+    #[weak]
     #[cfg(not(any(target_os = "ios", target_env = "msvc")))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memmove8(dest: *mut u8, src: *const u8, n: usize) {
         __aeabi_memmove(dest, src, n);
     }
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memset(dest: *mut u8, n: usize, c: i32) {
         // Note the different argument order
         ::mem::memset(dest, c, n);
     }
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memset4(dest: *mut u8, n: usize, c: i32) {
         let mut dest = dest as *mut u32;
         let mut n = n;
@@ -161,26 +161,26 @@ intrinsics! {
         __aeabi_memset(dest as *mut u8, n, byte as i32);
     }
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memset8(dest: *mut u8, n: usize, c: i32) {
         __aeabi_memset4(dest, n, c);
     }
 
+    #[weak]
     #[cfg(not(target_os = "ios"))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memclr(dest: *mut u8, n: usize) {
         __aeabi_memset(dest, n, 0);
     }
 
+    #[weak]
     #[cfg(not(any(target_os = "ios", target_env = "msvc")))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memclr4(dest: *mut u8, n: usize) {
         __aeabi_memset4(dest, n, 0);
     }
 
+    #[weak]
     #[cfg(not(any(target_os = "ios", target_env = "msvc")))]
-    #[linkage = "weak"]
     pub unsafe extern "aapcs" fn __aeabi_memclr8(dest: *mut u8, n: usize) {
         __aeabi_memset4(dest, n, 0);
     }
diff --git a/src/macros.rs b/src/macros.rs
index 477c2568..59f25317 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -25,6 +25,12 @@ macro_rules! public_test_dep {
 /// platforms need and elsewhere in this library it just looks like normal Rust
 /// code.
 ///
+/// When the weak-intrinsics feature is enabled, all intrinsics functions are
+/// marked with #[linkage = "weak"] so that they can be replaced by another
+/// implementation at link time. This is particularly useful for mixed Rust/C++
+/// binaries that want to use the C++ intrinsics, otherwise linking against the
+/// Rust stdlib will replace those from the compiler-rt library.
+///
 /// This macro is structured to be invoked with a bunch of functions that looks
 /// like:
 ///
@@ -46,6 +52,10 @@ macro_rules! public_test_dep {
 ///
 /// A quick overview of attributes supported right now are:
 ///
+/// * `weak` - indicates that the function should always be given weak linkage.
+///   This attribute must come before other attributes, as the other attributes
+///   will generate the final output function and need to have `weak` modify
+///   them.
 /// * `maybe_use_optimized_c_shim` - indicates that the Rust implementation is
 ///   ignored if an optimized C version was compiled.
 /// * `aapcs_on_arm` - forces the ABI of the function to be `"aapcs"` on ARM and
@@ -57,7 +67,6 @@ macro_rules! public_test_dep {
 ///   it's a normal ABI elsewhere for returning a 128 bit integer.
 /// * `arm_aeabi_alias` - handles the "aliasing" of various intrinsics on ARM
 ///   their otherwise typical names to other prefixed ones.
-///
 macro_rules! intrinsics {
     () => ();
 
@@ -89,6 +98,95 @@ macro_rules! intrinsics {
 
         intrinsics!($($rest)*);
     );
+    // Same as above but for unsafe.
+    (
+        #[cfg_attr($e:meta, $($attr:tt)*)]
+        $(#[$($attrs:tt)*])*
+        pub unsafe extern $abi:tt fn $name:ident( $($argname:ident: $ty:ty),* ) $(-> $ret:ty)? {
+            $($body:tt)*
+        }
+        $($rest:tt)*
+    ) => (
+        #[cfg($e)]
+        intrinsics! {
+            #[$($attr)*]
+            $(#[$($attrs)*])*
+            pub unsafe extern $abi fn $name($($argname: $ty),*) $(-> $ret)? {
+                $($body)*
+            }
+        }
+
+        #[cfg(not($e))]
+        intrinsics! {
+            $(#[$($attrs)*])*
+            pub unsafe extern $abi fn $name($($argname: $ty),*) $(-> $ret)? {
+                $($body)*
+            }
+        }
+
+        intrinsics!($($rest)*);
+    );
+
+    // Explicit weak linkage gets dropped when weak-intrinsics is on since it
+    // will be added unconditionally to all intrinsics and would conflict
+    // otherwise.
+    (
+        #[weak]
+        $(#[$($attr:tt)*])*
+        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) $(-> $ret:ty)? {
+            $($body:tt)*
+        }
+
+        $($rest:tt)*
+    ) => (
+        #[cfg(feature = "weak-intrinsics")]
+        intrinsics! {
+            $(#[$($attr)*])*
+            pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
+                $($body)*
+            }
+        }
+
+        #[cfg(not(feature = "weak-intrinsics"))]
+        intrinsics! {
+            $(#[$($attr)*])*
+            #[linkage = "weak"]
+            pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
+                $($body)*
+            }
+        }
+
+        intrinsics!($($rest)*);
+    );
+    // Same as above but for unsafe.
+    (
+        #[weak]
+        $(#[$($attr:tt)*])*
+        pub unsafe extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) $(-> $ret:ty)? {
+            $($body:tt)*
+        }
+
+        $($rest:tt)*
+    ) => (
+        #[cfg(feature = "weak-intrinsics")]
+        intrinsics! {
+            $(#[$($attr)*])*
+            pub unsafe extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
+                $($body)*
+            }
+        }
+
+        #[cfg(not(feature = "weak-intrinsics"))]
+        intrinsics! {
+            $(#[$($attr)*])*
+            #[linkage = "weak"]
+            pub unsafe extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
+                $($body)*
+            }
+        }
+
+        intrinsics!($($rest)*);
+    );
 
     // Right now there's a bunch of architecture-optimized intrinsics in the
     // stock compiler-rt implementation. Not all of these have been ported over
@@ -112,6 +210,7 @@ macro_rules! intrinsics {
         $($rest:tt)*
     ) => (
         #[cfg($name = "optimized-c")]
+        #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
         pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
             extern $abi {
                 fn $name($($argname: $ty),*) $(-> $ret)?;
@@ -211,6 +310,7 @@ macro_rules! intrinsics {
     ) => (
         #[cfg(all(any(windows, target_os = "uefi"), target_arch = "x86_64"))]
         $(#[$($attr)*])*
+        #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
         pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
             $($body)*
         }
@@ -218,6 +318,7 @@ macro_rules! intrinsics {
         #[cfg(all(any(windows, target_os = "uefi"), target_arch = "x86_64"))]
         pub mod $name {
             #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+            #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
             pub extern $abi fn $name( $($argname: $ty),* )
                 -> ::macros::win64_128bit_abi_hack::U64x2
             {
@@ -258,6 +359,7 @@ macro_rules! intrinsics {
         #[cfg(target_arch = "arm")]
         pub mod $name {
             #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+            #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
             pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
                 super::$name($($argname),*)
             }
@@ -266,7 +368,7 @@ macro_rules! intrinsics {
         #[cfg(target_arch = "arm")]
         pub mod $alias {
             #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
-            #[cfg_attr(all(not(windows), not(target_vendor="apple")), linkage = "weak")]
+            #[cfg_attr(any(all(not(windows), not(target_vendor="apple"), feature = "weak-intrinsics")), linkage = "weak")]
             pub extern "aapcs" fn $alias( $($argname: $ty),* ) $(-> $ret)? {
                 super::$name($($argname),*)
             }
@@ -302,6 +404,7 @@ macro_rules! intrinsics {
         pub mod $name {
             $(#[$($attr)*])*
             #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+            #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
             pub unsafe extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
                 super::$name($($argname),*)
             }
@@ -325,6 +428,7 @@ macro_rules! intrinsics {
             #[naked]
             $(#[$($attr)*])*
             #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+            #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
             pub unsafe extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
                 $($body)*
             }
@@ -391,6 +495,7 @@ macro_rules! intrinsics {
         pub mod $name {
             $(#[$($attr)*])*
             #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+            #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
             pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
                 super::$name($($argname),*)
             }
@@ -416,6 +521,7 @@ macro_rules! intrinsics {
         pub mod $name {
             $(#[$($attr)*])*
             #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+            #[cfg_attr(feature = "weak-intrinsics", linkage = "weak")]
             pub unsafe extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
                 super::$name($($argname),*)
             }
diff --git a/src/mem/mod.rs b/src/mem/mod.rs
index be118778..ccf19177 100644
--- a/src/mem/mod.rs
+++ b/src/mem/mod.rs
@@ -20,15 +20,15 @@ use core::ops::{BitOr, Shl};
 mod impls;
 
 intrinsics! {
+    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), weak)]
     #[mem_builtin]
-    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), linkage = "weak")]
     pub unsafe extern "C" fn memcpy(dest: *mut u8, src: *const u8, n: usize) -> *mut u8 {
         impls::copy_forward(dest, src, n);
         dest
     }
 
+    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), weak)]
     #[mem_builtin]
-    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), linkage = "weak")]
     pub unsafe extern "C" fn memmove(dest: *mut u8, src: *const u8, n: usize) -> *mut u8 {
         let delta = (dest as usize).wrapping_sub(src as usize);
         if delta >= n {
@@ -41,27 +41,27 @@ intrinsics! {
         dest
     }
 
+    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), weak)]
     #[mem_builtin]
-    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), linkage = "weak")]
     pub unsafe extern "C" fn memset(s: *mut u8, c: crate::mem::c_int, n: usize) -> *mut u8 {
         impls::set_bytes(s, c as u8, n);
         s
     }
 
+    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), weak)]
     #[mem_builtin]
-    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), linkage = "weak")]
     pub unsafe extern "C" fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32 {
         impls::compare_bytes(s1, s2, n)
     }
 
+    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), weak)]
     #[mem_builtin]
-    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), linkage = "weak")]
     pub unsafe extern "C" fn bcmp(s1: *const u8, s2: *const u8, n: usize) -> i32 {
         memcmp(s1, s2, n)
     }
 
+    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), weak)]
     #[mem_builtin]
-    #[cfg_attr(not(all(target_os = "windows", target_env = "gnu")), linkage = "weak")]
     pub unsafe extern "C" fn strlen(s: *const core::ffi::c_char) -> usize {
         impls::c_string_length(s)
     }