__aeabi_lmul on thumbv6m-none-eabi

[seeday]

Managed to track a crash when using lmul down to what seems to be a stack overflow, with a loop between the __aeabi_lmul and __muldi3 functions. I think it's due to 0x6ccc in this dump.

[japaric]

I think this is how the disassembly was produced:

$ cargo new --bin app && cd $_

$ edit src/main.rs && cat $_
#![feature(compiler_builtins_lib)]
#![feature(lang_items)]
#![no_main]
#![no_std]

extern crate compiler_builtins;

use core::ptr;

#[no_mangle]
pub fn _start() -> ! {
    let x = unsafe {
        ptr::read_volatile(0x0 as *const u32)
    };
    let y = x * (48000000 / 1000000) / 3;

    loop {}
}

#[lang = "panic_fmt"]
#[no_mangle]
fn panic_fmt() {}

#[no_mangle]
pub fn __aeabi_unwind_cpp_pr0() {}

$ xargo rustc --target thumbv6m-none-eabi -- -C link-arg=-nostartfiles

[seeday]

@japaric correct. For completeness here's the full function.

pub fn udelay(us: u32) {
    if us == 0 {
        return;
    }

    let n = us * (48_000_000 / 1_000_000) / 3;
    unsafe {
        asm!("1:
          subs $0, #1
          bne 1b
         " :: "r" (n));
    }
}

[parched]

I had a look at the LLVM IR on playground and it seems that rustc calls the intrinsic @llvm.umul.with.overflow.i32 for all the normal multiplications in __muldi3 here in debug mode. That instrinic calls __aeabi_lmul as @seeday spotted which calls __muldi3 and hence the infinite recursion. Replacing the normal multiplications with wrapping_mul should solve the problem I believe.

[nezza]

@parched Hi, thanks for taking the time to look at this! Do you happen to have a rough patch idea for that? I am unfortunately not yet deep enough into the compiler-rt code but am facing the same issue.
Thanks in advance!

[nezza]

@parched Wow, thanks for the fast patch. I can confirm this works for me and stops the infinite recursion from happening.