M-Labs/compiler-builtins-zynq
8
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Replace {u,i}128_* lang items with __rust_{u,i}128_* unmangled functions

Browse Source 
The -Zlower-128bit-ops feature is completely broken, as libcore needs
those lang items to compile with this feature, but they are only
provided by compiler_builtins, which itself depends on libcore.
According to rust-lang/rust#58969 the feature never got finished.

This commit removes the associated lang items and replaces them with
normal unmangled functions, when there is no existing intrinsic. This
makes it easier for alternative codegen backends to implement 128bit
integer support.
This commit is contained in:
bjorn3 2019-07-13 11:38:35 +02:00
parent 5e06435c29
commit 783430e6ae
6 changed files with 37 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/int/addsub.rs
View File

@ -90,44 +90,43 @@ where
impl Subo for i128 {}
impl Subo for u128 {}
u128_lang_items! {
#[lang = "i128_add"]
pub fn rust_i128_add(a: i128, b: i128) -> i128 {
rust_u128_add(a as _, b as _) as _
intrinsics! {
pub extern "C" fn __rust_i128_add(a: i128, b: i128) -> i128 {
__rust_u128_add(a as _, b as _) as _
}
#[lang = "i128_addo"]
pub fn rust_i128_addo(a: i128, b: i128) -> (i128, bool) {
let mut oflow = 0;
let r = a.addo(b, &mut oflow);
(r, oflow != 0)
}
#[lang = "u128_add"]
pub fn rust_u128_add(a: u128, b: u128) -> u128 {
a.add(b)
}
#[lang = "u128_addo"]
pub fn rust_u128_addo(a: u128, b: u128) -> (u128, bool) {
pub extern "C" fn __rust_i128_addo(a: i128, b: i128) -> (i128, bool) {
let mut oflow = 0;
let r = a.addo(b, &mut oflow);
(r, oflow != 0)
}
#[lang = "i128_sub"]
pub fn rust_i128_sub(a: i128, b: i128) -> i128 {
rust_u128_sub(a as _, b as _) as _
pub extern "C" fn __rust_u128_add(a: u128, b: u128) -> u128 {
a.add(b)
}
#[lang = "i128_subo"]
pub fn rust_i128_subo(a: i128, b: i128) -> (i128, bool) {
pub extern "C" fn __rust_u128_addo(a: u128, b: u128) -> (u128, bool) {
let mut oflow = 0;
let r = a.addo(b, &mut oflow);
(r, oflow != 0)
}
pub extern "C" fn __rust_i128_sub(a: i128, b: i128) -> i128 {
__rust_u128_sub(a as _, b as _) as _
}
pub extern "C" fn __rust_i128_subo(a: i128, b: i128) -> (i128, bool) {
let mut oflow = 0;
let r = a.subo(b, &mut oflow);
(r, oflow != 0)
}
#[lang = "u128_sub"]
pub fn rust_u128_sub(a: u128, b: u128) -> u128 {
pub extern "C" fn __rust_u128_sub(a: u128, b: u128) -> u128 {
a.sub(b)
}
#[lang = "u128_subo"]
pub fn rust_u128_subo(a: u128, b: u128) -> (u128, bool) {
pub extern "C" fn __rust_u128_subo(a: u128, b: u128) -> (u128, bool) {
let mut oflow = 0;
let r = a.subo(b, &mut oflow);
(r, oflow != 0)

17
src/int/mul.rs
View File

@ -107,25 +107,14 @@ intrinsics! {
pub extern "C" fn __muloti4(a: i128, b: i128, oflow: &mut i32) -> i128 {
a.mulo(b, oflow)
}
}
u128_lang_items! {
#[lang = "i128_mul"]
pub fn rust_i128_mul(a: i128, b: i128) -> i128 {
__multi3(a, b)
}
#[lang = "i128_mulo"]
pub fn rust_i128_mulo(a: i128, b: i128) -> (i128, bool) {
pub extern "C" fn __rust_i128_mulo(a: i128, b: i128) -> (i128, bool) {
let mut oflow = 0;
let r = __muloti4(a, b, &mut oflow);
(r, oflow != 0)
}
#[lang = "u128_mul"]
pub fn rust_u128_mul(a: u128, b: u128) -> u128 {
__multi3(a as _, b as _) as _
}
#[lang = "u128_mulo"]
pub fn rust_u128_mulo(a: u128, b: u128) -> (u128, bool) {
pub extern "C" fn __rust_u128_mulo(a: u128, b: u128) -> (u128, bool) {
let mut oflow = 0;
let r = a.mulo(b, &mut oflow);
(r, oflow != 0)

11
src/int/sdiv.rs
View File

@ -99,14 +99,3 @@ intrinsics! {
a.divmod(b, rem, |a, b| __divdi3(a, b))
}
}
u128_lang_items! {
#[lang = "i128_div"]
pub fn rust_i128_div(a: i128, b: i128) -> i128 {
__divti3(a, b)
}
#[lang = "i128_rem"]
pub fn rust_i128_rem(a: i128, b: i128) -> i128 {
__modti3(a, b)
}
}

40
src/int/shift.rs
View File

@ -103,40 +103,20 @@ intrinsics! {
pub extern "C" fn __lshrti3(a: u128, b: u32) -> u128 {
a.lshr(b)
}
}
u128_lang_items! {
#[lang = "i128_shl"]
pub fn rust_i128_shl(a: i128, b: u32) -> i128 {
__ashlti3(a as _, b) as _
}
#[lang = "i128_shlo"]
pub fn rust_i128_shlo(a: i128, b: u128) -> (i128, bool) {
(rust_i128_shl(a, b as _), b >= 128)
}
#[lang = "u128_shl"]
pub fn rust_u128_shl(a: u128, b: u32) -> u128 {
__ashlti3(a, b)
}
#[lang = "u128_shlo"]
pub fn rust_u128_shlo(a: u128, b: u128) -> (u128, bool) {
(rust_u128_shl(a, b as _), b >= 128)
pub extern "C" fn __rust_i128_shlo(a: i128, b: u128) -> (i128, bool) {
(__ashlti3(a as _, b as _) as _, b >= 128)
}
#[lang = "i128_shr"]
pub fn rust_i128_shr(a: i128, b: u32) -> i128 {
__ashrti3(a, b)
pub extern "C" fn __rust_u128_shlo(a: u128, b: u128) -> (u128, bool) {
(__ashlti3(a, b as _), b >= 128)
}
#[lang = "i128_shro"]
pub fn rust_i128_shro(a: i128, b: u128) -> (i128, bool) {
(rust_i128_shr(a, b as _), b >= 128)
pub extern "C" fn __rust_i128_shro(a: i128, b: u128) -> (i128, bool) {
(__ashrti3(a, b as _), b >= 128)
}
#[lang = "u128_shr"]
pub fn rust_u128_shr(a: u128, b: u32) -> u128 {
__lshrti3(a, b)
}
#[lang = "u128_shro"]
pub fn rust_u128_shro(a: u128, b: u128) -> (u128, bool) {
(rust_u128_shr(a, b as _), b >= 128)
pub extern "C" fn __rust_u128_shro(a: u128, b: u128) -> (u128, bool) {
(__lshrti3(a, b as _), b >= 128)
}
}

11
src/int/udiv.rs
View File

@ -268,14 +268,3 @@ intrinsics! {
udivmod_inner!(n, d, rem, u128)
}
}
u128_lang_items! {
#[lang = "u128_div"]
pub fn rust_u128_div(a: u128, b: u128) -> u128 {
__udivti3(a, b)
}
#[lang = "u128_rem"]
pub fn rust_u128_rem(a: u128, b: u128) -> u128 {
__umodti3(a, b)
}
}

14
src/macros.rs
View File

@ -280,17 +280,3 @@ pub mod win64_128bit_abi_hack {
}
}
}
macro_rules! u128_lang_items {
($(
#[lang = $lang:tt]
pub fn $name:ident( $($argname:ident: $ty:ty),* ) -> $ret:ty {
$($body:tt)*
}
)*) => ($(
#[cfg_attr(not(any(stage0, feature = "no-lang-items")), lang = $lang)]
pub fn $name( $($argname: $ty),* ) -> $ret {
$($body)*
}
)*)
}