From fbf1586c5d850f52d8affde8b3daf4a73258eb97 Mon Sep 17 00:00:00 2001
From: Patryk Wychowaniec <pwychowaniec@pm.me>
Date: Sun, 15 May 2022 12:58:38 +0200
Subject: [PATCH] Fix division on AVRs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

For division and modulo, AVR uses a custom calling convention that does
not match compiler_builtins' expectations, leading to non-working code¹.

Ideally we'd just use hand-written naked functions (as, afair, ARM
does), but that's a lot of code to port², so hopefully we'll be able to
do it gradually later.

For the time being, I'd suggest not compiling problematic functions for
AVR target - this causes avr-gcc (which is a mandatory part of Rust+AVR
toolchain anyway) to link hand-written assembly from libgcc, which is
confirmed to work.

I've tested the code locally on simavr and the patch seems to be working
correctly :-)

¹ https://github.com/rust-lang/rust/issues/82242,
  https://github.com/rust-lang/rust/issues/83281
² https://github.com/gcc-mirror/gcc/blob/31048012db98f5ec9c2ba537bfd850374bdd771f/libgcc/config/avr/lib1funcs.S

Closes https://github.com/rust-lang/rust/issues/82242
Closes https://github.com/rust-lang/rust/issues/83281
---
 src/int/sdiv.rs |  1 +
 src/int/udiv.rs |  3 +++
 src/macros.rs   | 31 ++++++++++++++++++++++++++++++-
 3 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/int/sdiv.rs b/src/int/sdiv.rs
index e1e3f33bb..d526b105b 100644
--- a/src/int/sdiv.rs
+++ b/src/int/sdiv.rs
@@ -9,6 +9,7 @@ macro_rules! sdivmod {
         $($attr:tt),* // attributes
     ) => {
         intrinsics! {
+            #[avr_skip]
             $(
                 #[$attr]
             )*
diff --git a/src/int/udiv.rs b/src/int/udiv.rs
index 2f236346d..4b92ae324 100644
--- a/src/int/udiv.rs
+++ b/src/int/udiv.rs
@@ -18,6 +18,7 @@ intrinsics! {
         u32_div_rem(n, d).1
     }
 
+    #[avr_skip]
     #[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 {
@@ -40,6 +41,7 @@ intrinsics! {
         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 {
@@ -77,6 +79,7 @@ intrinsics! {
         }
     }
 
+    #[avr_skip]
     #[win64_128bit_abi_hack]
     /// Returns `n / d` and sets `*rem = n % d`
     pub extern "C" fn __udivmodti4(n: u128, d: u128, rem: Option<&mut u128>) -> u128 {
diff --git a/src/macros.rs b/src/macros.rs
index 6926feac0..4c1d8af62 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -82,7 +82,6 @@ macro_rules! intrinsics {
 
         $($rest:tt)*
     ) => (
-
         #[cfg($name = "optimized-c")]
         pub extern $abi fn $name( $($argname: $ty),* ) $(-> $ret)? {
             extern $abi {
@@ -304,6 +303,36 @@ macro_rules! intrinsics {
         intrinsics!($($rest)*);
     );
 
+    // For division and modulo, 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.