stop compiling some compiler-rt implementations that have already

been ported to Rust. Being careful of still preferring compiler-rt
arch-optimized implementations.

Author: Jorge Aparicio

build.rs

@@ -101,13 +101,9 @@ fn main() {
         let mut sources = Sources::new();
         sources.extend(&["absvdi2.c",
                         "absvsi2.c",
-                        "adddf3.c",
-                        "addsf3.c",
                         "addvdi3.c",
                         "addvsi3.c",
                         "apple_versioning.c",
-                        "ashldi3.c",
-                        "ashrdi3.c",
                         "clear_cache.c",
                         "clzdi2.c",
                         "clzsi2.c",
@@ -118,12 +114,8 @@ fn main() {
                         "ctzsi2.c",
                         "divdc3.c",
                         "divdf3.c",
-                        "divdi3.c",
-                        "divmoddi4.c",
-                        "divmodsi4.c",
                         "divsc3.c",
                         "divsf3.c",
-                        "divsi3.c",
                         "divxc3.c",
                         "extendsfdf2.c",
                         "extendhfsf2.c",
@@ -150,14 +142,8 @@ fn main() {
                         "floatunsidf.c",
                         "floatunsisf.c",
                         "int_util.c",
-                        "lshrdi3.c",
-                        "moddi3.c",
-                        "modsi3.c",
                         "muldc3.c",
                         "muldf3.c",
-                        "muldi3.c",
-                        "mulodi4.c",
-                        "mulosi4.c",
                         "muloti4.c",
                         "mulsc3.c",
                         "mulsf3.c",
@@ -183,13 +169,7 @@ fn main() {
                         "truncdfhf2.c",
                         "truncdfsf2.c",
                         "truncsfhf2.c",
-                        "ucmpdi2.c",
-                        "udivdi3.c",
-                        "udivmoddi4.c",
-                        "udivmodsi4.c",
-                        "udivsi3.c",
-                        "umoddi3.c",
-                        "umodsi3.c"]);
+                        "ucmpdi2.c"]);
 
         if target_os != "ios" {
             sources.extend(&["absvti2.c",

ci/script.sh

@@ -41,8 +41,6 @@ inspect() {
         set -e
     fi
 
-    # verify we haven't drop any intrinsic/symbol
-    cargo rustc --features c --target $TARGET --bin intrinsics
 }
 
 run_tests() {
@@ -56,6 +54,20 @@ run_tests() {
     fi
 }
 
+c_test() {
+    $CARGO clean
+
+    # verify we haven't drop any intrinsic/symbol
+    $CARGO build --features c --target $TARGET --bin intrinsics
+
+    set +e
+    # verify that we don't have duplicated symbols when we include symbols from compiler-rt
+    $PREFIX$NM --defined-only target/$TARGET/debug/librustc_builtins.rlib | sort | uniq -d | grep 'T __'
+
+    [[ $? == 0 ]] && exit 1
+    set -e
+}
+
 main() {
     if [[ $LINUX && ${IN_DOCKER_CONTAINER:-n} == n ]]; then
         # NOTE The Dockerfile of this image is in the docker branch of this repository
@@ -76,6 +88,7 @@ main() {
         build
         inspect
         run_tests
+        c_test
     fi
 }
 

src/arm.rs

@@ -68,6 +68,7 @@ pub extern "C" fn __aeabi_fadd(a: f32, b: f32) -> f32 {
     ::float::add::__addsf3(a, b)
 }
 
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __aeabi_idiv(a: i32, b: i32) -> i32 {
     ::int::sdiv::__divsi3(a, b)
@@ -93,6 +94,7 @@ pub extern "C" fn __aeabi_lmul(a: u64, b: u64) -> u64 {
     ::int::mul::__muldi3(a, b)
 }
 
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __aeabi_uidiv(a: u32, b: u32) -> u32 {
     ::int::udiv::__udivsi3(a, b)

src/int/mul.rs

@@ -66,7 +66,9 @@ macro_rules! mulo {
     }
 }
 
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 mul!(__muldi3: u64);
+
 mulo!(__mulosi4: i32);
 mulo!(__mulodi4: i64);
 

src/int/sdiv.rs

@@ -36,18 +36,33 @@ macro_rules! divmod {
         /// Returns `a / b` and sets `*rem = n % d`
         #[cfg_attr(not(test), no_mangle)]
         pub extern "C" fn $intrinsic(a: $ty, b: $ty, rem: &mut $ty) -> $ty {
-            let r = $div(a, b);
+            #[cfg(all(feature = "c", any(target_arch = "x86")))]
+            extern {
+                fn $div(a: $ty, b: $ty) -> $ty;
+            }
+
+            let r = unsafe { $div(a, b) };
             *rem = a - (r * b);
             r
         }
     }
 }
 
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 div!(__divsi3: i32, u32);
+
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 div!(__divdi3: i64, u64);
+
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 mod_!(__modsi3: i32, u32);
+
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 mod_!(__moddi3: i64, u64);
+
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 divmod!(__divmodsi4, __divsi3: i32);
+
 divmod!(__divmoddi4, __divdi3: i64);
 
 #[cfg(test)]

src/int/shift.rs

@@ -54,8 +54,13 @@ macro_rules! lshr {
     }
 }
 
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 ashl!(__ashldi3: u64);
+
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 ashr!(__ashrdi3: i64);
+
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 lshr!(__lshrdi3: u64);
 
 #[cfg(test)]

src/int/udiv.rs

@@ -2,6 +2,7 @@ use core::mem;
 use int::{Int, LargeInt};
 
 /// Returns `n / d`
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __udivsi3(n: u32, d: u32) -> u32 {
     // Special cases
@@ -52,14 +53,26 @@ pub extern "C" fn __udivsi3(n: u32, d: u32) -> u32 {
 }
 
 /// Returns `n % d`
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __umodsi3(n: u32, d: u32) -> u32 {
-    n - __udivsi3(n, d) * d
+    #[cfg(all(feature = "c", target_arch = "arm", not(target_os = "ios")))]
+    extern {
+        fn __udivsi3(n: u32, d: u32) -> u32;
+    }
+
+    n - unsafe { __udivsi3(n, d) * d }
 }
 
 /// Returns `n / d` and sets `*rem = n % d`
+#[cfg(not(all(feature = "c", target_arch = "arm", not(target_os = "ios"))))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __udivmodsi4(n: u32, d: u32, rem: Option<&mut u32>) -> u32 {
+    #[cfg(all(feature = "c", target_arch = "arm", not(target_os = "ios")))]
+    extern {
+        fn __udivsi3(n: u32, d: u32) -> u32;
+    }
+
     let q = __udivsi3(n, d);
     if let Some(rem) = rem {
         *rem = n - (q * d);
@@ -69,11 +82,13 @@ pub extern "C" fn __udivmodsi4(n: u32, d: u32, rem: Option<&mut u32>) -> u32 {
 
 /// Returns `n / d`
 #[cfg_attr(not(test), no_mangle)]
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 pub extern "C" fn __udivdi3(n: u64, d: u64) -> u64 {
     __udivmoddi4(n, d, None)
 }
 
 /// Returns `n % d`
+#[cfg(not(all(feature = "c", target_arch = "x86")))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __umoddi3(a: u64, b: u64) -> u64 {
     let mut rem = unsafe { mem::uninitialized() };

src/lib.rs

@@ -10,6 +10,9 @@
 // We disable #[no_mangle] for tests so that we can verify the test results
 // against the native compiler-rt implementations of the builtins.
 
+// NOTE cfg(all(feature = "c", ..)) indicate that compiler-rt provides an arch optimized
+// implementation of that intrinsic and we'll prefer to use that
+
 #[cfg(test)]
 #[macro_use]
 extern crate quickcheck;