avr: Skip No More!

compiler-builtins/src/float/add.rs

@@ -189,14 +189,12 @@ where
 }
 
 intrinsics! {
-    #[avr_skip]
     #[aapcs_on_arm]
     #[arm_aeabi_alias = __aeabi_fadd]
     pub extern "C" fn __addsf3(a: f32, b: f32) -> f32 {
         add(a, b)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[arm_aeabi_alias = __aeabi_dadd]
     pub extern "C" fn __adddf3(a: f64, b: f64) -> f64 {

compiler-builtins/src/float/cmp.rs

@@ -3,6 +3,14 @@
 use crate::float::Float;
 use crate::int::MinInt;
 
+// https://github.com/llvm/llvm-project/blob/1e6ba3cd2fe96be00b6ed6ba28b3d9f9271d784d/compiler-rt/lib/builtins/fp_compare_impl.inc#L22
+#[cfg(target_arch = "avr")]
+pub type CmpResult = i8;
+
+// https://github.com/llvm/llvm-project/blob/1e6ba3cd2fe96be00b6ed6ba28b3d9f9271d784d/compiler-rt/lib/builtins/fp_compare_impl.inc#L25
+#[cfg(not(target_arch = "avr"))]
+pub type CmpResult = i32;
+
 #[derive(Clone, Copy)]
 enum Result {
     Less,
@@ -12,7 +20,7 @@ enum Result {
 }
 
 impl Result {
-    fn to_le_abi(self) -> i32 {
+    fn to_le_abi(self) -> CmpResult {
         match self {
             Result::Less => -1,
             Result::Equal => 0,
@@ -21,7 +29,7 @@ impl Result {
         }
     }
 
-    fn to_ge_abi(self) -> i32 {
+    fn to_ge_abi(self) -> CmpResult {
         match self {
             Result::Less => -1,
             Result::Equal => 0,
@@ -99,120 +107,99 @@ fn unord<F: Float>(a: F, b: F) -> bool {
 }
 
 intrinsics! {
-    #[avr_skip]
-    pub extern "C" fn __lesf2(a: f32, b: f32) -> i32 {
+    pub extern "C" fn __lesf2(a: f32, b: f32) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __gesf2(a: f32, b: f32) -> i32 {
+    pub extern "C" fn __gesf2(a: f32, b: f32) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_ge_abi()
     }
 
-    #[avr_skip]
     #[arm_aeabi_alias = __aeabi_fcmpun]
-    pub extern "C" fn __unordsf2(a: f32, b: f32) -> i32 {
-        unord(a, b) as i32
+    pub extern "C" fn __unordsf2(a: f32, b: f32) -> crate::float::cmp::CmpResult {
+        unord(a, b) as crate::float::cmp::CmpResult
     }
 
-    #[avr_skip]
-    pub extern "C" fn __eqsf2(a: f32, b: f32) -> i32 {
+    pub extern "C" fn __eqsf2(a: f32, b: f32) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __ltsf2(a: f32, b: f32) -> i32 {
+    pub extern "C" fn __ltsf2(a: f32, b: f32) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __nesf2(a: f32, b: f32) -> i32 {
+    pub extern "C" fn __nesf2(a: f32, b: f32) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __gtsf2(a: f32, b: f32) -> i32 {
+    pub extern "C" fn __gtsf2(a: f32, b: f32) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_ge_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __ledf2(a: f64, b: f64) -> i32 {
+    pub extern "C" fn __ledf2(a: f64, b: f64) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __gedf2(a: f64, b: f64) -> i32 {
+    pub extern "C" fn __gedf2(a: f64, b: f64) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_ge_abi()
     }
 
-    #[avr_skip]
     #[arm_aeabi_alias = __aeabi_dcmpun]
-    pub extern "C" fn __unorddf2(a: f64, b: f64) -> i32 {
-        unord(a, b) as i32
+    pub extern "C" fn __unorddf2(a: f64, b: f64) -> crate::float::cmp::CmpResult {
+        unord(a, b) as crate::float::cmp::CmpResult
     }
 
-    #[avr_skip]
-    pub extern "C" fn __eqdf2(a: f64, b: f64) -> i32 {
+    pub extern "C" fn __eqdf2(a: f64, b: f64) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __ltdf2(a: f64, b: f64) -> i32 {
+    pub extern "C" fn __ltdf2(a: f64, b: f64) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __nedf2(a: f64, b: f64) -> i32 {
+    pub extern "C" fn __nedf2(a: f64, b: f64) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
-    pub extern "C" fn __gtdf2(a: f64, b: f64) -> i32 {
+    pub extern "C" fn __gtdf2(a: f64, b: f64) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_ge_abi()
     }
 }
 
 #[cfg(f128_enabled)]
 intrinsics! {
-    #[avr_skip]
     #[ppc_alias = __lekf2]
-    pub extern "C" fn __letf2(a: f128, b: f128) -> i32 {
+    pub extern "C" fn __letf2(a: f128, b: f128) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
     #[ppc_alias = __gekf2]
-    pub extern "C" fn __getf2(a: f128, b: f128) -> i32 {
+    pub extern "C" fn __getf2(a: f128, b: f128) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_ge_abi()
     }
 
-    #[avr_skip]
     #[ppc_alias = __unordkf2]
-    pub extern "C" fn __unordtf2(a: f128, b: f128) -> i32 {
-        unord(a, b) as i32
+    pub extern "C" fn __unordtf2(a: f128, b: f128) -> crate::float::cmp::CmpResult {
+        unord(a, b) as crate::float::cmp::CmpResult
     }
 
-    #[avr_skip]
     #[ppc_alias = __eqkf2]
-    pub extern "C" fn __eqtf2(a: f128, b: f128) -> i32 {
+    pub extern "C" fn __eqtf2(a: f128, b: f128) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
     #[ppc_alias = __ltkf2]
-    pub extern "C" fn __lttf2(a: f128, b: f128) -> i32 {
+    pub extern "C" fn __lttf2(a: f128, b: f128) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
     #[ppc_alias = __nekf2]
-    pub extern "C" fn __netf2(a: f128, b: f128) -> i32 {
+    pub extern "C" fn __netf2(a: f128, b: f128) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_le_abi()
     }
 
-    #[avr_skip]
     #[ppc_alias = __gtkf2]
-    pub extern "C" fn __gttf2(a: f128, b: f128) -> i32 {
+    pub extern "C" fn __gttf2(a: f128, b: f128) -> crate::float::cmp::CmpResult {
         cmp(a, b).to_ge_abi()
     }
 }

compiler-builtins/src/float/div.rs

@@ -606,19 +606,16 @@ where
 }
 
 intrinsics! {
-    #[avr_skip]
     #[arm_aeabi_alias = __aeabi_fdiv]
     pub extern "C" fn __divsf3(a: f32, b: f32) -> f32 {
         div(a, b)
     }
 
-    #[avr_skip]
     #[arm_aeabi_alias = __aeabi_ddiv]
     pub extern "C" fn __divdf3(a: f64, b: f64) -> f64 {
         div(a, b)
     }
 
-    #[avr_skip]
     #[ppc_alias = __divkf3]
     #[cfg(f128_enabled)]
     pub extern "C" fn __divtf3(a: f128, b: f128) -> f128 {

compiler-builtins/src/float/extend.rs

@@ -70,7 +70,6 @@ where
 }
 
 intrinsics! {
-    #[avr_skip]
     #[aapcs_on_arm]
     #[arm_aeabi_alias = __aeabi_f2d]
     pub extern "C" fn  __extendsfdf2(a: f32) -> f64 {
@@ -79,7 +78,6 @@ intrinsics! {
 }
 
 intrinsics! {
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_arg_abi]
     #[arm_aeabi_alias = __aeabi_h2f]
@@ -88,39 +86,34 @@ intrinsics! {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_arg_abi]
     #[cfg(f16_enabled)]
     pub extern "C" fn __gnu_h2f_ieee(a: f16) -> f32 {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_arg_abi]
     #[cfg(f16_enabled)]
     pub extern "C" fn __extendhfdf2(a: f16) -> f64 {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __extendhfkf2]
     #[cfg(all(f16_enabled, f128_enabled))]
     pub extern "C" fn __extendhftf2(a: f16) -> f128 {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __extendsfkf2]
     #[cfg(f128_enabled)]
     pub extern "C" fn __extendsftf2(a: f32) -> f128 {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __extenddfkf2]
     #[cfg(f128_enabled)]

compiler-builtins/src/float/mul.rs

@@ -180,14 +180,12 @@ where
 }
 
 intrinsics! {
-    #[avr_skip]
     #[aapcs_on_arm]
     #[arm_aeabi_alias = __aeabi_fmul]
     pub extern "C" fn __mulsf3(a: f32, b: f32) -> f32 {
         mul(a, b)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[arm_aeabi_alias = __aeabi_dmul]
     pub extern "C" fn __muldf3(a: f64, b: f64) -> f64 {

compiler-builtins/src/float/pow.rs

@@ -26,17 +26,14 @@ fn pow<F: Float>(a: F, b: i32) -> F {
 }
 
 intrinsics! {
-    #[avr_skip]
     pub extern "C" fn __powisf2(a: f32, b: i32) -> f32 {
         pow(a, b)
     }
 
-    #[avr_skip]
     pub extern "C" fn __powidf2(a: f64, b: i32) -> f64 {
         pow(a, b)
     }
 
-    #[avr_skip]
     #[ppc_alias = __powikf2]
     #[cfg(f128_enabled)]
     // FIXME(f16_f128): MSVC cannot build these until `__divtf3` is available in nightly.

compiler-builtins/src/float/sub.rs

@@ -1,13 +1,11 @@
 use crate::float::Float;
 
 intrinsics! {
-    #[avr_skip]
     #[arm_aeabi_alias = __aeabi_fsub]
     pub extern "C" fn __subsf3(a: f32, b: f32) -> f32 {
         crate::float::add::__addsf3(a, f32::from_bits(b.to_bits() ^ f32::SIGN_MASK))
     }
 
-    #[avr_skip]
     #[arm_aeabi_alias = __aeabi_dsub]
     pub extern "C" fn __subdf3(a: f64, b: f64) -> f64 {
         crate::float::add::__adddf3(a, f64::from_bits(b.to_bits() ^ f64::SIGN_MASK))

compiler-builtins/src/float/trunc.rs

@@ -115,7 +115,6 @@ where
 }
 
 intrinsics! {
-    #[avr_skip]
     #[aapcs_on_arm]
     #[arm_aeabi_alias = __aeabi_d2f]
     pub extern "C" fn __truncdfsf2(a: f64) -> f32 {
@@ -124,7 +123,6 @@ intrinsics! {
 }
 
 intrinsics! {
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_ret_abi]
     #[arm_aeabi_alias = __aeabi_f2h]
@@ -133,15 +131,13 @@ intrinsics! {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_ret_abi]
     #[cfg(f16_enabled)]
     pub extern "C" fn __gnu_f2h_ieee(a: f32) -> f16 {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_ret_abi]
     #[arm_aeabi_alias = __aeabi_d2h]
@@ -150,23 +146,20 @@ intrinsics! {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __trunckfhf2]
     #[cfg(all(f16_enabled, f128_enabled))]
     pub extern "C" fn __trunctfhf2(a: f128) -> f16 {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __trunckfsf2]
     #[cfg(f128_enabled)]
     pub extern "C" fn __trunctfsf2(a: f128) -> f32 {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __trunckfdf2]
     #[cfg(f128_enabled)]

compiler-builtins/src/int/bswap.rs

@@ -1,20 +1,17 @@
 intrinsics! {
     #[maybe_use_optimized_c_shim]
-    #[avr_skip]
     /// Swaps bytes in 32-bit number
     pub extern "C" fn __bswapsi2(x: u32) -> u32 {
         x.swap_bytes()
     }
 
     #[maybe_use_optimized_c_shim]
-    #[avr_skip]
     /// Swaps bytes in 64-bit number
     pub extern "C" fn __bswapdi2(x: u64) -> u64 {
         x.swap_bytes()
     }
 
     #[maybe_use_optimized_c_shim]
-    #[avr_skip]
     /// Swaps bytes in 128-bit number
     pub extern "C" fn __bswapti2(x: u128) -> u128 {
         x.swap_bytes()