t = trunc (5.0)
    display '0' + t, 10
    t = trunc (2*2.499999)
    display '0' + t, 10
    t = trunc (2*2.5)
    display '0' + t, 10
    t = trunc (2*2.500001)
    display '0' + t, 10

    t = trunc (-5.0)
    display '0' - t, 10
    t = trunc (2*-2.499999)
    display '0' - t, 10
    t = trunc (2*-2.5)
    display '0' - t, 10
    t = trunc (2*-2.500001)
    display '0' - t, 10
    

5
4
4
5
5
4
4
5    

; when b/a is exactly representable by the float data
; type, I don't think we should get an error here
a = 3
b = 6
if (float a)*((float b)/(float a)) = float b
else
    err 'oops'
end if    

1/3   = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * 2^-129
6     = 0xc0000000000000000000000000000000 * 2^-125
6*1/3 = 0x7fffffffffffffffffffffffffffffff80000000000000000000000000000000 * 2^-254
this last number is going to get shifted to
        0xffffffffffffffffffffffffffffffff * 2^-127    

Correct me if I am wrong on the following points:
(1) floats are represented by a 32 bit exponent and a 32n bit mantissa.
(2) the highest bit in the mantissa of a non-zero float is always 1
(3) a*b is calculated by calculating 64n bits but doing rounding on only 32n + 32 bits.
(4) a/b is calculated as a*(1/b)

As for (3), why not do the rounding on all 64n bits?

If you want to fix (4), you are probably going to have to do the gradeschool algorithm. (I went to grade school but didn't learn this algorithm properly there)
I have some notes on how to do this properly and I could share them with you. This
would save you the headache if you don't have this working already. Because of (2),
this is going to be slightly easier in fasmg than it was for me.

Do you allow others to submit patches to fasmg?

An asdembler with arbitary precision floats as well as ints would be nice, though the latter can be used to simulate the former.

So you are essentially talking about arithmetic over Q since correct handling of 1 + 2^-1000 while choaking on 2/3 would be considered strange behaviour by almost any user.

Could you give some hints on how your division works? Does it produce the quotient segments in order from high to low? What is the complexity?

This is a revised version of the algorithm used by fasm 1 for division by 64-bit number, it computes iterated approximations until remainder is smaller than the divisor. The first approximation is made with baseline division by 32-bit value (made from the most significant bits of the divisor).

So it seems you have never implemented a proper grade school division algorithm!

I reworked the arbitrary precision floats in my cas project so that rounding is exact and to the nearest even (this of course then requires that the highest bit in the mantissa is set, like in your implementation). The result is clean simple c code that I hope you can translate into the fasmg core. If I get it thoroughly tested, would you be willing to take some time to translate the code into fasmg?

As for code size and temporary workspace, division and multiplication are about the same for the former and equal for the latter.

In my case translating the code would probably end up changing to simply writing my own variant in assembly.