OSDev.org

HugeCode wrote:Is it enough to change only muls to imuls?

    result = (v1.high * v2.high) << 64 + (v1.high * v2.low) << 32 + (v1.low * v2.high) << 32 + v1.low * v2.low

    sign = (v1.high ^ v2.high) >> 31;  // Determine sign of result
    result = abs(v1) * abs(v2);        // Unsigned multiplication
    if(sign != 0) {     
        result = -result;              // Negate result if result should've been negative
    }

• What needs to be done with numbers when performing signed division? (Maybe just sign determination and then usage of unsigned division code as for multiplication?)
• Is there any way for performing 64bit/64bit division, or it's not needed and 64/32 bit division is enough for every operation?

HugeCode wrote:Ok, now what about division? Brendan, in this topic I found your post containing code with 64bit division. Below it, there was comment about signed division, that in printf function (the topic was about it) there should be added '-' before number.
I have two more questions on 64bit division:

• What needs to be done with numbers when performing signed division? (Maybe just sign determination and then usage of unsigned division code as for multiplication?)
• Is there any way for performing 64bit/64bit division, or it's not needed and 64/32 bit division is enough for every operation?

Thanks.

    result = 0;
    count = 0;
    remainder = numerator;

    while(highest_bit_of_divisor_not_set) {
        divisor = divisor << 1;
        count++;
    }
    while(remainder != 0) {
        if(remainder > divisor) {
            remainder = remainder - divisor;
            result = result | (1 << count);
        }
        if(count == 0) {
            break;
        }
        divisor = divisor >> 1;
        count--;
    }

• shifting left by 1 ('add' and 'adc', to add the value to itself instead)
• shifting right by 1 ('shr' and 'rcr' instructions)
• comparison (multiple 'cmp' instructions)
• subtraction ('sub' and 'sbb')
• setting a bit (the 'bts' instruction works well if your result is in memory)

I don't understand that substractions. What are they for? What do you mean by the high part (maybe high 64bits, or high 32)?

div64:
mov ecx,Denominator
or ecx,Denominator+4
jz dividedbyzero
fild Numerator
fild Denominator
fld st
fdivr st,st(2)
frndint
fld st
fistp Quotient
fmulp st(1),st
fsubp st(1),st
fistp Remainder
ret

public __aulldiv
__aulldiv:
mov eax,[esp+8]
mov ecx,[esp+16]
jecxz divu64_32
cmp eax,ecx
jb divu_0
push esi
mov edx,ecx
bsr ecx,edx
mov esi,[esp+16]
shrd esi,edx,cl
xchg edx,eax
mov eax,[esp+8]
cmp edx,esi
jb divu_ok
shrd eax,edx,1
shr edx,1
dec ecx
divu_ok:
div esi
add ecx,edi
shrd eax,edx,cl
mov esi,eax
mov ecx,eax
mul dword ptr [esp+16]
imul ecx,[esp+20]
add edx,ecx
sub eax,[esp+8]
sbb edx,[esp+12]
js divu_nofix
dec esi
divu_nofix:
mov eax,esi
xor edx,edx
pop esi
ret 16
divu64_32:
xor edx,edx
div dword ptr [esp+12]
push eax
mov eax,[esp+8]
div dword ptr [esp+16]
pop edx
ret 16
divu_0:
xor eax,eax
cdq
ret 16
public __aullrem
__aullrem:
mov eax,[esp+8]
mov ecx,[esp+16]
jecxz remu64_32
cmp eax,ecx
jb remu_0
push esi
mov edx,ecx
bsr ecx,edx
mov esi,[esp+16]
shrd esi,edx,cl
xchg edx,eax
mov eax,[esp+8]
cmp edx,esi
jb remu_ok
shrd eax,edx,1
shr edx,1
dec ecx
remu_ok:
div esi
add ecx,edi
shrd eax,edx,cl
mov ecx,eax
mul dword ptr [esp+16]
imul ecx,[esp+20]
add edx,ecx
sub eax,[esp+8]
sbb edx,[esp+12]
js remu_nofix
sub eax,[esp+16]
sbb edx,[esp+20]
remu_nofix:
neg eax
adc edx,0
neg edx
pop esi
ret 16
remu64_32:
xor edx,edx
div dword ptr [esp+12]
mov eax,[esp+4]
div dword ptr [esp+16]
xchg edx,eax
xor edx,edx
ret 16
remu_0:
xchg edx,eax
mov eax,[esp+4]
ret 16

sortie wrote:If this is related to doing a 64-bit division on a 32-bit target using GCC - then you should build libgcc along with your cross-compiler and simply link your kernel with it. It will handle division of 64-bit integers for you along with other useful things that GCC relies on libgcc for.

Griwes wrote:

sortie wrote:If this is related to doing a 64-bit division on a 32-bit target using GCC - then you should build libgcc along with your cross-compiler and simply link your kernel with it. It will handle division of 64-bit integers for you along with other useful things that GCC relies on libgcc for.

So you are basically saying "don't reinvent the wheel" to someone posting on OSDev forums?

sortie wrote:

Griwes wrote:

sortie wrote:If this is related to doing a 64-bit division on a 32-bit target using GCC - then you should build libgcc along with your cross-compiler and simply link your kernel with it. It will handle division of 64-bit integers for you along with other useful things that GCC relies on libgcc for.

So you are basically saying "don't reinvent the wheel" to someone posting on OSDev forums?

Haha - Nah, my point is that you shouldn't reinvent parts that the compiler supplies. If you insist on doing that, then you probably should reinvent the entire compiler as well.

HugeCode wrote:Brendan:
On this line:

Code: Select all

 if(remainder > divisor) {

wouldn't it be better if there was >=? For example if you try to divide two 64bit numbers with MSB=0x80 (result x/x=1), then (it looks like it for me) it won't work... There will be result 1 and remainder.