diff --git a/compiler-builtins/src/float/add.rs b/compiler-builtins/src/float/add.rs
index ef04ddc16..0426c9cc4 100644
--- a/compiler-builtins/src/float/add.rs
+++ b/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 {
diff --git a/compiler-builtins/src/float/cmp.rs b/compiler-builtins/src/float/cmp.rs
index b9b4d0114..296952821 100644
--- a/compiler-builtins/src/float/cmp.rs
+++ b/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()
     }
 }
diff --git a/compiler-builtins/src/float/div.rs b/compiler-builtins/src/float/div.rs
index 21c757dd6..929f29197 100644
--- a/compiler-builtins/src/float/div.rs
+++ b/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 {
diff --git a/compiler-builtins/src/float/extend.rs b/compiler-builtins/src/float/extend.rs
index ce00da31d..c4f1fe30e 100644
--- a/compiler-builtins/src/float/extend.rs
+++ b/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,7 +86,6 @@ intrinsics! {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_arg_abi]
     #[cfg(f16_enabled)]
@@ -96,7 +93,6 @@ intrinsics! {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_arg_abi]
     #[cfg(f16_enabled)]
@@ -104,7 +100,6 @@ intrinsics! {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __extendhfkf2]
     #[cfg(all(f16_enabled, f128_enabled))]
@@ -112,7 +107,6 @@ intrinsics! {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __extendsfkf2]
     #[cfg(f128_enabled)]
@@ -120,7 +114,6 @@ intrinsics! {
         extend(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __extenddfkf2]
     #[cfg(f128_enabled)]
diff --git a/compiler-builtins/src/float/mul.rs b/compiler-builtins/src/float/mul.rs
index 58636cb5e..7f1f19d9b 100644
--- a/compiler-builtins/src/float/mul.rs
+++ b/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 {
diff --git a/compiler-builtins/src/float/pow.rs b/compiler-builtins/src/float/pow.rs
index dac768f7b..fe76060e0 100644
--- a/compiler-builtins/src/float/pow.rs
+++ b/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.
diff --git a/compiler-builtins/src/float/sub.rs b/compiler-builtins/src/float/sub.rs
index 175b3a165..a0fd9dff9 100644
--- a/compiler-builtins/src/float/sub.rs
+++ b/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))
diff --git a/compiler-builtins/src/float/trunc.rs b/compiler-builtins/src/float/trunc.rs
index 928eba0c8..ca8a0f368 100644
--- a/compiler-builtins/src/float/trunc.rs
+++ b/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,7 +131,6 @@ intrinsics! {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_ret_abi]
     #[cfg(f16_enabled)]
@@ -141,7 +138,6 @@ intrinsics! {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[apple_f16_ret_abi]
     #[arm_aeabi_alias = __aeabi_d2h]
@@ -150,7 +146,6 @@ intrinsics! {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __trunckfhf2]
     #[cfg(all(f16_enabled, f128_enabled))]
@@ -158,7 +153,6 @@ intrinsics! {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __trunckfsf2]
     #[cfg(f128_enabled)]
@@ -166,7 +160,6 @@ intrinsics! {
         trunc(a)
     }
 
-    #[avr_skip]
     #[aapcs_on_arm]
     #[ppc_alias = __trunckfdf2]
     #[cfg(f128_enabled)]
diff --git a/compiler-builtins/src/int/bswap.rs b/compiler-builtins/src/int/bswap.rs
index 9df80204d..3ede08882 100644
--- a/compiler-builtins/src/int/bswap.rs
+++ b/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()
diff --git a/compiler-builtins/src/int/sdiv.rs b/compiler-builtins/src/int/sdiv.rs
index 9630c7d7d..6a9029de7 100644
--- a/compiler-builtins/src/int/sdiv.rs
+++ b/compiler-builtins/src/int/sdiv.rs
@@ -9,7 +9,6 @@ macro_rules! sdivmod {
         $($attr:tt),* // attributes
     ) => {
         intrinsics! {
-            #[avr_skip]
             $(
                 #[$attr]
             )*
@@ -19,15 +18,18 @@ macro_rules! sdivmod {
                 let b_neg = b < 0;
                 let mut a = a;
                 let mut b = b;
+
                 if a_neg {
                     a = a.wrapping_neg();
                 }
                 if b_neg {
                     b = b.wrapping_neg();
                 }
+
                 let mut r = *rem as $uX;
                 let t = $unsigned_fn(a as $uX, b as $uX, Some(&mut r)) as $iX;
                 let mut r = r as $iX;
+
                 if a_neg {
                     r = r.wrapping_neg();
                 }
@@ -51,7 +53,6 @@ macro_rules! sdiv {
         $($attr:tt),* // attributes
     ) => {
         intrinsics! {
-            #[avr_skip]
             $(
                 #[$attr]
             )*
@@ -87,7 +88,6 @@ macro_rules! smod {
         $($attr:tt),* // attributes
     ) => {
         intrinsics! {
-            #[avr_skip]
             $(
                 #[$attr]
             )*
@@ -114,6 +114,7 @@ macro_rules! smod {
     }
 }
 
+#[cfg(not(target_arch = "avr"))]
 sdivmod!(
     __udivmodsi4,
     __divmodsi4,
@@ -121,6 +122,41 @@ sdivmod!(
     i32,
     maybe_use_optimized_c_shim
 );
+
+#[cfg(target_arch = "avr")]
+intrinsics! {
+    /// Returns `a / b` and `a % b` packed together.
+    ///
+    /// Ideally we'd use `-> (u32, u32)` or some kind of a packed struct, but
+    /// both force a stack allocation, while our result has to be in R18:R26.
+    pub extern "C" fn __divmodsi4(a: i32, b: i32) -> u64 {
+        let a_neg = a < 0;
+        let b_neg = b < 0;
+        let mut a = a;
+        let mut b = b;
+
+        if a_neg {
+            a = a.wrapping_neg();
+        }
+        if b_neg {
+            b = b.wrapping_neg();
+        }
+
+        let tr = __udivmodsi4(a as u32, b as u32);
+        let mut t = tr as u32 as i32;
+        let mut r = (tr >> 32) as u32 as i32;
+
+        if a_neg {
+            r = r.wrapping_neg();
+        }
+        if a_neg != b_neg {
+            t = t.wrapping_neg();
+        }
+
+        ((r as u32 as u64) << 32) | (t as u32 as u64)
+    }
+}
+
 // The `#[arm_aeabi_alias = __aeabi_idiv]` attribute cannot be made to work with `intrinsics!` in macros
 intrinsics! {
     #[maybe_use_optimized_c_shim]
diff --git a/compiler-builtins/src/int/shift.rs b/compiler-builtins/src/int/shift.rs
index 317272988..a85c1b33d 100644
--- a/compiler-builtins/src/int/shift.rs
+++ b/compiler-builtins/src/int/shift.rs
@@ -69,56 +69,47 @@ impl Lshr for u64 {}
 impl Lshr for u128 {}
 
 intrinsics! {
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     pub extern "C" fn __ashlsi3(a: u32, b: u32) -> u32 {
         a.ashl(b)
     }
 
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     #[arm_aeabi_alias = __aeabi_llsl]
     pub extern "C" fn __ashldi3(a: u64, b: core::ffi::c_uint) -> u64 {
         a.ashl(b as u32)
     }
 
-    #[avr_skip]
     pub extern "C" fn __ashlti3(a: u128, b: u32) -> u128 {
         a.ashl(b)
     }
 
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     pub extern "C" fn __ashrsi3(a: i32, b: u32) -> i32 {
         a.ashr(b)
     }
 
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     #[arm_aeabi_alias = __aeabi_lasr]
     pub extern "C" fn __ashrdi3(a: i64, b: core::ffi::c_uint) -> i64 {
         a.ashr(b as u32)
     }
 
-    #[avr_skip]
     pub extern "C" fn __ashrti3(a: i128, b: u32) -> i128 {
         a.ashr(b)
     }
 
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     pub extern "C" fn __lshrsi3(a: u32, b: u32) -> u32 {
         a.lshr(b)
     }
 
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     #[arm_aeabi_alias = __aeabi_llsr]
     pub extern "C" fn __lshrdi3(a: u64, b: core::ffi::c_uint) -> u64 {
         a.lshr(b as u32)
     }
 
-    #[avr_skip]
     pub extern "C" fn __lshrti3(a: u128, b: u32) -> u128 {
         a.lshr(b)
     }
diff --git a/compiler-builtins/src/int/udiv.rs b/compiler-builtins/src/int/udiv.rs
index 1fa761212..a5c16040a 100644
--- a/compiler-builtins/src/int/udiv.rs
+++ b/compiler-builtins/src/int/udiv.rs
@@ -17,8 +17,10 @@ intrinsics! {
     pub extern "C" fn __umodsi3(n: u32, d: u32) -> u32 {
         u32_div_rem(n, d).1
     }
+}
 
-    #[avr_skip]
+#[cfg(not(target_arch = "avr"))]
+intrinsics! {
     #[maybe_use_optimized_c_shim]
     /// Returns `n / d` and sets `*rem = n % d`
     pub extern "C" fn __udivmodsi4(n: u32, d: u32, rem: Option<&mut u32>) -> u32 {
@@ -28,22 +30,34 @@ intrinsics! {
         }
         quo_rem.0
     }
+}
+
+#[cfg(target_arch = "avr")]
+intrinsics! {
+    /// Returns `n / d` and `n % d` packed together.
+    ///
+    /// Ideally we'd use `-> (u32, u32)` or some kind of a packed struct, but
+    /// both force a stack allocation, while our result has to be in R18:R26.
+    pub extern "C" fn __udivmodsi4(n: u32, d: u32) -> u64 {
+        let (div, rem) = u32_div_rem(n, d);
 
-    #[avr_skip]
+        ((rem as u64) << 32) | (div as u64)
+    }
+}
+
+intrinsics! {
     #[maybe_use_optimized_c_shim]
     /// Returns `n / d`
     pub extern "C" fn __udivdi3(n: u64, d: u64) -> u64 {
         u64_div_rem(n, d).0
     }
 
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     /// Returns `n % d`
     pub extern "C" fn __umoddi3(n: u64, d: u64) -> u64 {
         u64_div_rem(n, d).1
     }
 
-    #[avr_skip]
     #[maybe_use_optimized_c_shim]
     /// Returns `n / d` and sets `*rem = n % d`
     pub extern "C" fn __udivmoddi4(n: u64, d: u64, rem: Option<&mut u64>) -> u64 {
@@ -57,7 +71,6 @@ intrinsics! {
     // Note: we use block configuration and not `if cfg!(...)`, because we need to entirely disable
     // the existence of `u128_div_rem` to get 32-bit SPARC to compile, see `u128_divide_sparc` docs.
 
-    #[avr_skip]
     /// Returns `n / d`
     pub extern "C" fn __udivti3(n: u128, d: u128) -> u128 {
         #[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))] {
@@ -68,7 +81,6 @@ intrinsics! {
         }
     }
 
-    #[avr_skip]
     /// Returns `n % d`
     pub extern "C" fn __umodti3(n: u128, d: u128) -> u128 {
         #[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))] {
@@ -81,7 +93,6 @@ intrinsics! {
         }
     }
 
-    #[avr_skip]
     /// Returns `n / d` and sets `*rem = n % d`
     pub extern "C" fn __udivmodti4(n: u128, d: u128, rem: Option<&mut u128>) -> u128 {
         #[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))] {
diff --git a/compiler-builtins/src/macros.rs b/compiler-builtins/src/macros.rs
index b1b71379c..0397e4551 100644
--- a/compiler-builtins/src/macros.rs
+++ b/compiler-builtins/src/macros.rs
@@ -445,35 +445,6 @@ macro_rules! intrinsics {
         intrinsics!($($rest)*);
     );
 
-    // For some intrinsics, AVR uses a custom calling convention¹ that does not
-    // match our definitions here. Ideally we would just use hand-written naked
-    // functions, but that's quite a lot of code to port² - so for the time
-    // being we are just ignoring the problematic functions, letting avr-gcc
-    // (which is required to compile to AVR anyway) link them from libgcc.
-    //
-    // ¹ https://gcc.gnu.org/wiki/avr-gcc (see "Exceptions to the Calling
-    //   Convention")
-    // ² https://github.com/gcc-mirror/gcc/blob/31048012db98f5ec9c2ba537bfd850374bdd771f/libgcc/config/avr/lib1funcs.S
-    (
-        #[avr_skip]
-        $(#[$($attr:tt)*])*
-        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) $(-> $ret:ty)? {
-            $($body:tt)*
-        }
-
-        $($rest:tt)*
-    ) => (
-        #[cfg(not(target_arch = "avr"))]
-        intrinsics! {
-            $(#[$($attr)*])*
-            pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
-                $($body)*
-            }
-        }
-
-        intrinsics!($($rest)*);
-    );
-
     // This is the final catch-all rule. At this point we generate an
     // intrinsic with a conditional `#[no_mangle]` directive to avoid
     // interfering with duplicate symbols and whatnot during testing.
diff --git a/testcrate/tests/misc.rs b/testcrate/tests/misc.rs
index f5ac2ab7d..edbd3684d 100644
--- a/testcrate/tests/misc.rs
+++ b/testcrate/tests/misc.rs
@@ -175,7 +175,6 @@ fn trailing_zeros() {
 }
 
 #[test]
-#[cfg(not(target_arch = "avr"))]
 fn bswap() {
     use compiler_builtins::int::bswap::{__bswapdi2, __bswapsi2};
     fuzz(N, |x: u32| {