Advice required for code using multiplication & division operations

[tnm23]

Given the complete lack of hardware support for multiplication or division in most (all?) attinys, how does the Arduino compiler handle code that contains mathematical operators like *, /, % when using ATTinyCore? Is it safe to use them, or will they produce awful, gigantic, slow code, or just fail to compile at all? is it generally recommended to avoid using these and write one's own explicit arithmetic algorithms (using the Russian Peasant algorithm or something of that nature) instead of using the inbuilt operators? IIRC it's not permitted to overload the pre-defined mathematical infix operators for inbuilt operands like integers in standard CPP, but is there perhaps an unofficial, dirty way to do it so that libraries written using these operators will compile correctly using customised definitions for them?

[sleemanj]

You can use all such operations, the compiler will take care of the necessary to accomplish it, it will not fail to compile absent other errors.

You are unlikely to be able to write better more optimised code than the compiler will.

Avoid floating point.

[prandeamus]

I agree. In 99% of situations the compiler will do a better job than you, unless you are an experienced AVR assembly coder. If you can re-code the algorithms to avoid multiplication, division, floating point you might benefit. The classic example used to be that x*2 could be optimised as x<<1, but these days most compilers can handle this sort of thing without blinking.

I did some experiments a few years ago to do multiplication on an ATTiny85 using a ROM-based lookup table having all possible combinations of 4 bit operands (0..15 * 0..15). As I recall this can squeeze a little performance but at the expense of code complexity and ROM. In the case of 4 bit operations there are 16*16=256 possible outcomes, you can reduce the size of that lookup table to just over half because multiplication is commutative, and you can do lookups that way. Interesting hack for its own sake, but not for everyone.

This is a compiler and instruction set issue rather than the ATTinyCore package itself

https://gcc.gnu.org/wiki/avr-gcc
Sections "exceptions to the Calling Convention" and "Reduced Tiny" might be of interest.

[prandeamus]

Oh and if you're prepared to wade into c++ operator overload syntax, you can do clever things to over-ride operators in certain situations, but if you get it wrong it's a world of pain ensuring that a = a*c is consistent with a *= c. At least, as I recall: it was a while ago.