Skip to content

Add the weak-intrinsics feature #526

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
May 20, 2023
Merged

Add the weak-intrinsics feature #526

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
11 changes: 11 additions & 0 deletions Cargo.toml
View file
Open in desktop
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
Open in desktop
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
Open in desktop
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