Are there available math libraries in assembly for the STM32G031 type processors?

[JCase.1]

I'm using an STM32G031F8 for a job right now. I'm coding in GCC assembly, no OS. This thing doesn't even have a hardware divide (much less FPU). I pulled out some old routines from NXP ARM7 chips for doing unsigned div 32 bit by 32 bit and 32 bit by 16 bit, but those are in full ARM code....This is minimal thumb code. It looks extremely cumbersome to translate them, since the instruction set for this chip won't do an LSR or LSL without setting the condition flags, and all the routines I have need the condition flags to be retained across shifts.

Is there any available library of optimized assembly math routines for these processors? I don't need a whole pile of them, right now I'd be content with a div 32 by 16. Thanks!

[Danish1]

You don’t say why you’re choosing to use assembly rather than (say) C.

Compilers have such subroutines to hand, and will attach them to your code as appropriate. So you could do worse than writing a small program that needs a division and seeing what the compiler produces. (You’ll need to convince the compiler not to do the division at compile-time rather than run-time).

But don’t forget that the greatest optimisation is not to have to divide at all, or not do it more than necessary. If you divide by the same value more than once, it can be faster to calculate the reciprocal once, then multiply by that as and when needed. You’ll need to choose an appropriate fixed-point representation.

[JCase.1]

No, I didn't say. I was not looking for a discussion on my toolset, I was looking for a solution.

And I am quite aware of ways to get around doing a divide, but certain calibrations require at least one divide done at init time to generate a calibration constant.

Never mind, I already wrote it.

[JCase.1]

in case anybody else has a use for this:

(I apologize for the lousy formatting, the tabs got all messed up.)

.global uDIV3215 // cheesy unsigned divide, R0 is numerator on entry, R1 is denominator
uDIV3215: push {r1,r2,r3,lr} // R0 is quotient on exit
 
 cmp r1,0
 beq _zonk // divide by 0
 ldr r2,=1<<16
 cmp r1,r2
 bge _zonk // denominator too large
 
 ldr r2,=0 // r2 is the answer, built bit by bit starting MSB
 lsls r1,15 // start with comparison of numerator to denominator * 2^15
 ldr r3,=1<<15
 
_loop: cmp r0,r1 // is remainder (so far) > denominator * 2^N ?
 blt _next // no, just shift down for next
 subs r0,r1 // yes, so reduce remainder...
 adds r2,r3 // ... and add a bit to the quotient
_next: lsrs r1,1 // divide denominator *2^N by 2
 lsrs r3,1 // shift mask
 bne _loop // back jack do it again
 mov r0,r2
 pop {r1,r2,r3,pc}
_zonk: ldr r0,=-1
 pop {r1,r2,r3,pc}