Remove some unused rust specific intrinsics

I think they were originally introduced when 128bit int support was
added to rustc but before LLVM consistently supported 128bit int
operations across platforms. Nowadays LLVM and GCC handle 128bit int
operations for us rather than manually adding calls to
rust specific intrinsics. The only exception is the Cranelift backend
which still uses the __rust_u/i128_mulo intrinsics and as such this
commit keeps those around.

Author: bjorn3

src/int/addsub.rs

@@ -2,7 +2,6 @@ use core::ops;
 
 mod specialized_div_rem;
 
-pub mod addsub;
 mod big;
 pub mod bswap;
 pub mod leading_zeros;

src/int/mod.rs

@@ -3,81 +3,6 @@
 
 use testcrate::*;
 
-mod int_addsub {
-    use super::*;
-
-    macro_rules! sum {
-        ($($i:ty, $fn_add:ident, $fn_sub:ident);*;) => {
-            $(
-                #[test]
-                fn $fn_add() {
-                    use compiler_builtins::int::addsub::{$fn_add, $fn_sub};
-
-                    fuzz_2(N, |x: $i, y: $i| {
-                        let add0 = x.wrapping_add(y);
-                        let sub0 = x.wrapping_sub(y);
-                        let add1: $i = $fn_add(x, y);
-                        let sub1: $i = $fn_sub(x, y);
-                        if add0 != add1 {
-                            panic!(
-                                "{}({}, {}): std: {}, builtins: {}",
-                                stringify!($fn_add), x, y, add0, add1
-                            );
-                        }
-                        if sub0 != sub1 {
-                            panic!(
-                                "{}({}, {}): std: {}, builtins: {}",
-                                stringify!($fn_sub), x, y, sub0, sub1
-                            );
-                        }
-                    });
-                }
-            )*
-        };
-    }
-
-    macro_rules! overflowing_sum {
-        ($($i:ty, $fn_add:ident, $fn_sub:ident);*;) => {
-            $(
-                #[test]
-                fn $fn_add() {
-                    use compiler_builtins::int::addsub::{$fn_add, $fn_sub};
-
-                    fuzz_2(N, |x: $i, y: $i| {
-                        let add0 = x.overflowing_add(y);
-                        let sub0 = x.overflowing_sub(y);
-                        let add1: ($i, bool) = $fn_add(x, y);
-                        let sub1: ($i, bool) = $fn_sub(x, y);
-                        if add0.0 != add1.0 || add0.1 != add1.1 {
-                            panic!(
-                                "{}({}, {}): std: {:?}, builtins: {:?}",
-                                stringify!($fn_add), x, y, add0, add1
-                            );
-                        }
-                        if sub0.0 != sub1.0 || sub0.1 != sub1.1 {
-                            panic!(
-                                "{}({}, {}): std: {:?}, builtins: {:?}",
-                                stringify!($fn_sub), x, y, sub0, sub1
-                            );
-                        }
-                    });
-                }
-            )*
-        };
-    }
-
-    // Integer addition and subtraction is very simple, so 100 fuzzing passes should be plenty.
-    sum! {
-        u128, __rust_u128_add, __rust_u128_sub;
-        i128, __rust_i128_add, __rust_i128_sub;
-    }
-
-    overflowing_sum! {
-        u128, __rust_u128_addo, __rust_u128_subo;
-        i128, __rust_i128_addo, __rust_i128_subo;
-    }
-}
-
 macro_rules! float_sum {
     ($($f:ty, $fn_add:ident, $fn_sub:ident, $apfloat_ty:ident, $sys_available:meta);*;) => {
         $(