Skip to content

Commit

Permalink
Add the weak-intrinsics feature
Browse files Browse the repository at this point in the history 
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 rust-lang#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
```
  • Loading branch information
@danakj
danakj committed May 19, 2023
1 parent 4677881 commit af540c9
Show file tree
Hide file tree
Showing 4 changed files with 141 additions and 24 deletions.
11 changes: 11 additions & 0 deletions Cargo.toml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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"]
Expand Down
32 changes: 16 additions & 16 deletions src/arm.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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}}",
Expand All @@ -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}}",
Expand All @@ -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}}",
Expand All @@ -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}}",
Expand All @@ -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;
Expand All @@ -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;
Expand All @@ -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);
}
Expand Down
110 changes: 108 additions & 2 deletions src/macros.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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:
///
Expand All @@ -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
Expand All @@ -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 {
() => ();

Expand Down Expand Up @@ -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
Expand All @@ -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)?;
Expand Down Expand Up @@ -211,13 +310,15 @@ 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)*
}

#[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
{
Expand Down Expand Up @@ -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),*)
}
Expand All @@ -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),*)
}
Expand Down Expand Up @@ -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),*)
}
Expand All @@ -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)*
}
Expand Down Expand Up @@ -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),*)
}
Expand All @@ -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),*)
}
Expand Down
Loading

0 comments on commit af540c9

Please sign in to comment.