// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\euser\epoc\x86\uc_realx.cia

// 

//

#include "u32std.h"

#include <e32math.h>

void TRealXPanic(TInt aErr);

LOCAL_C __NAKED__ void TRealXPanicEax(void)

	{

	asm("push eax");

	asm("call %a0": : "i"(&TRealXPanic));

	}

LOCAL_C __NAKED__ void TRealXRealIndefinite(void)

	{

	// return 'real indefinite' NaN in ecx,edx:ebx

	asm("mov ecx, 0xFFFF0001");	// exponent=FFFF, sign negative

	asm("mov edx, 0xC0000000"); // mantissa=C0000000 00000000

	asm("xor ebx, ebx");

	asm("mov eax, -6"); // return KErrArgument

	asm("ret");

	}

LOCAL_C __NAKED__ void TRealXBinOpNaN(void)

	{

	// generic routine to process NaN's in binary operations

	// destination operand in ecx,edx:eax

	// source operand at [esi]

	asm("mov eax, [esi+8]");			// source operand into eax,edi:ebp

	asm("mov edi, [esi+4]");

	asm("mov ebp, [esi]");

	asm("cmp ecx, 0xFFFF0000");			// check if dest is a NaN

	asm("jb short TRealXBinOpNaN1");	// if not, swap them

	asm("cmp edx, 0x80000000");

	asm("jne short TRealXBinOpNaN2");

	asm("test ebx, ebx");

	asm("jne short TRealXBinOpNaN2");

	asm("TRealXBinOpNaN1:");			// swap the operands

	asm("xchg ecx, eax");

	asm("xchg edx, edi");

	asm("xchg ebx, ebp");

	asm("TRealXBinOpNaN2:");

	asm("cmp eax, 0xFFFF0000");			// check if both operands are NaNs

	asm("jb short TRealXBinOpNaN4");	// if not, ignore non-NaN operand

	asm("cmp edi, 0x80000000");

	asm("jne short TRealXBinOpNaN3");

	asm("test ebp, ebp");

	asm("je short TRealXBinOpNaN4");

	asm("TRealXBinOpNaN3:");			// if both operands are NaN's, compare significands

	asm("cmp edx, edi");

	asm("ja short TRealXBinOpNaN4");

	asm("jb short TRealXBinOpNaN5");

	asm("cmp ebx, ebp");

	asm("jae short TRealXBinOpNaN4");

	asm("TRealXBinOpNaN5:");			// come here if dest is smaller - copy source to dest

	asm("mov ecx, eax");

	asm("mov edx, edi");

	asm("mov ebx, ebp");

	asm("TRealXBinOpNaN4:");			// NaN with larger significand is in ecx,edx:ebx

	asm("or edx, 0x40000000");			// convert an SNaN to a QNaN

	asm("mov eax, -6");					// return KErrArgument

	asm("ret");

	}

// Add TRealX at [esi] + ecx,edx:ebx

// Result in ecx,edx:ebx

// Error code in eax

// Note:	+0 + +0 = +0, -0 + -0 = -0, +0 + -0 = -0 + +0 = +0,

//			+/-0 + X = X + +/-0 = X, X + -X = -X + X = +0

LOCAL_C __NAKED__ void TRealXAdd()

	{

	asm("xor ch, ch");				// clear rounding flags

	asm("cmp ecx, 0xFFFF0000");		// check if dest=NaN or infinity

	asm("jnc addfpsd");				// branch if it is

	asm("mov eax, [esi+8]");		// fetch sign/exponent of source

	asm("cmp eax, 0xFFFF0000");		// check if source=NaN or infinity

	asm("jnc addfpss");				// branch if it is

	asm("cmp eax, 0x10000");		// check if source=0

	asm("jc addfp0s");				// branch if it is

	asm("cmp ecx, 0x10000");		// check if dest=0

	asm("jc addfp0d");				// branch if it is

	asm("and cl, 1");				// clear bits 1-7 of ecx

	asm("and al, 1");				// clear bits 1-7 of eax

	asm("mov ch, cl");

	asm("xor ch, al");				// xor of signs into ch bit 0

	asm("add ch, ch");

	asm("or cl, ch");				// and into cl bit 1

	asm("or al, ch");				// and al bit 1

	asm("xor ch, ch");				// clear rounding flags

	asm("mov ebp, [esi]");			// fetch source mantissa 0-31

	asm("mov edi, [esi+4]");		// fetch source mantissa 32-63

	asm("ror ecx, 16");				// dest exponent into cx

	asm("ror eax, 16");				// source exponent into ax

	asm("push ecx");				// push dest exponent/sign

	asm("sub cx, ax");				// cx = dest exponent - source exponent

	asm("je short addfp3b");		// if equal, no shifting required

	asm("ja short addfp1");			// branch if dest exponent >= source exponent

	asm("xchg ebx, ebp");			// make sure edi:ebp contains the mantissa to be shifted

	asm("xchg edx, edi");			

	asm("xchg eax, [esp]");			// and larger exponent and corresponding sign is on the stack

	asm("neg cx");					// make cx positive = number of right shifts needed

	asm("addfp1:");

	asm("cmp cx, 64");				// if more than 64 shifts needed

	asm("ja addfp2");				// branch to output larger number

	asm("jb addfp3");				// branch if <64 shifts

	asm("mov eax, edi");			// exactly 64 shifts needed - rounding word=mant high

	asm("test ebp, ebp");			// check bits lost

	asm("jz short addfp3a");

	asm("or ch, 1");				// if not all zero, set rounded-down flag

	asm("addfp3a:");

	asm("xor edi, edi");			// clear edx:ebx

	asm("xor ebp, ebp");			

	asm("jmp short addfp5");		// finished shifting

	asm("addfp3b:");				// exponents equal

	asm("xor eax, eax");			// set rounding word=0

	asm("jmp short addfp5");

	asm("addfp3:");

	asm("cmp cl, 32");				// 32 or more shifts needed ?

	asm("jb short addfp4");			// skip if <32

	asm("mov eax, ebp");			// rounding word=mant low

	asm("mov ebp, edi");			// mant low=mant high

	asm("xor edi, edi");			// mant high=0

	asm("sub cl, 32");				// reduce count by 32

	asm("jz short addfp5");			// if now zero, finished shifting

	asm("shrd edi, eax, cl");		// shift ebp:eax:edi right by cl bits

	asm("shrd eax, ebp, cl");		//

	asm("shr ebp, cl");				//

	asm("test edi, edi");			// check bits lost in shift

	asm("jz short addfp5");			// if all zero, finished

	asm("or ch, 1");				// else set rounded-down flag

	asm("xor edi, edi");			// clear edx again

	asm("jmp short addfp5");		// finished shifting

	asm("addfp4:");					// <32 shifts needed now

	asm("xor eax, eax");			// clear rounding word initially

	asm("shrd eax, ebp, cl");		// shift edi:ebp:eax right by cl bits

	asm("shrd ebp, edi, cl");		//

	asm("shr edi, cl");				//

	asm("addfp5:");

	asm("mov [esp+3], ch");			// rounding flag into ch image on stack

	asm("pop ecx");					// recover sign and exponent into ecx, with rounding flag

	asm("ror ecx, 16");				// into normal position

	asm("test cl, 2");				// addition or subtraction needed ?

	asm("jnz short subfp1");		// branch if subtraction

	asm("add ebx,ebp");				// addition required - add mantissas

	asm("adc edx,edi");				//

	asm("jnc short roundfp");		// branch if no carry

	asm("rcr edx,1");				// shift carry right into mantissa

	asm("rcr ebx,1");				//

	asm("rcr eax,1");				// and into rounding word

	asm("jnc short addfp5a");

	asm("or ch, 1");				// if 1 shifted out, set rounded-down flag

	asm("addfp5a:");

	asm("add ecx, 0x10000");		// and increment exponent

	// perform rounding based on rounding word in eax and rounding flag in ch

	asm("roundfp:");

	asm("cmp eax, 0x80000000");		

	asm("jc roundfp0");				// if rounding word<80000000, round down

	asm("ja roundfp1");				// if >80000000, round up

	asm("test ch, 1");

	asm("jnz short roundfp1");		// if rounded-down flag set, round up

	asm("test ch, 2");

	asm("jnz short roundfp0");		// if rounded-up flag set, round down

	asm("test bl, 1");				// else test mantissa lsb

	asm("jz short roundfp0");		// round down if 0, up if 1 [round to even]

	asm("roundfp1:");				// Come here to round up

	asm("add ebx, 1");				// increment mantissa

	asm("adc edx,0");				//

	asm("jnc roundfp1a");			// if no carry OK

	asm("rcr edx,1");				// else shift carry into mantissa [edx:ebx=0 here]

	asm("add ecx, 0x10000");		// and increment exponent

	asm("roundfp1a:");

	asm("cmp ecx, 0xFFFF0000");		// check for overflow

	asm("jae short addfpovfw");		// jump if overflow

	asm("mov ch, 2");				// else set rounded-up flag

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	asm("roundfp0:");				// Come here to round down

	asm("cmp ecx, 0xFFFF0000");		// check for overflow

	asm("jae short addfpovfw");		// jump if overflow

	asm("test eax, eax");			// else check if rounding word zero

	asm("jz short roundfp0a");		// if so, leave rounding flags as they are

	asm("mov ch, 1");				// else set rounded-down flag

	asm("roundfp0a:");				

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	asm("addfpovfw:");				// Come here if overflow occurs

	asm("xor ch, ch");				// clear rounding flags, exponent=FFFF

	asm("xor ebx, ebx");

	asm("mov edx, 0x80000000");		// mantissa=80000000 00000000 for infinity

	asm("mov eax, -9");				// return KErrOverflow

	asm("ret");

	// exponents differ by more than 64 - output larger number

	asm("addfp2:");					

	asm("pop ecx");					// recover exponent and sign

	asm("ror ecx, 16");				// into normal position

	asm("or ch, 1");				// set rounded-down flag

	asm("test cl, 2");				// check if signs the same

	asm("jz addfp2a");

	asm("xor ch, 3");				// if not, set rounded-up flag

	asm("addfp2a:");

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	// signs differ, so must subtract mantissas

	asm("subfp1:");

	asm("add ch, ch");				// if rounded-down flag set, change it to rounded-up

	asm("neg eax");					// subtract rounding word from 0

	asm("sbb ebx, ebp");			// and subtract mantissas with borrow

	asm("sbb edx, edi");			//

	asm("jnc short subfp2");		// if no borrow, sign is correct

	asm("xor cl, 1");				// else change sign of result

	asm("shr ch, 1");				// change rounding back to rounded-down

	asm("not eax");					// negate rounding word

	asm("not ebx");					// and mantissa

	asm("not edx");					//

	asm("add eax,1");				// two's complement negation

	asm("adc ebx,0");				//

	asm("adc edx,0");				//

	asm("subfp2:");

	asm("jnz short subfp3");		// branch if edx non-zero at this point

	asm("mov edx, ebx");			// else shift ebx into edx

	asm("or edx, edx");				//

	asm("jz short subfp4");			// if still zero, branch

	asm("mov ebx, eax");			// else shift rounding word into ebx

	asm("xor eax, eax");			// and zero rounding word

	asm("sub ecx, 0x200000");		// decrease exponent by 32 due to shift

	asm("jnc short subfp3");		// if no borrow, carry on

	asm("jmp short subfpundflw");	// if borrow here, underflow

	asm("subfp4:");

	asm("mov edx, eax");			// move rounding word into edx

	asm("or edx, edx");				// is edx still zero ?

	asm("jz short subfp0");			// if so, result is precisely zero

	asm("xor ebx, ebx");			// else zero ebx and rounding word

	asm("xor eax, eax");			//

	asm("sub ecx, 0x400000");		// and decrease exponent by 64 due to shift

	asm("jc short subfpundflw");	// if borrow, underflow

	asm("subfp3:");

	asm("mov edi, ecx");			// preserve sign and exponent

	asm("bsr ecx, edx");			// position of most significant 1 into ecx

	asm("neg ecx");					//

	asm("add ecx, 31");				// cl = 31-position of MS 1 = number of shifts to normalise

	asm("shld edx, ebx, cl");		// shift edx:ebx:eax left by cl bits

	asm("shld ebx, eax, cl");		//

	asm("shl eax, cl");				//

	asm("mov ebp, ecx");			// bit count into ebp for subtraction

	asm("shl ebp, 16");				// shift left by 16 to align with exponent

	asm("mov ecx, edi");			// exponent, sign, rounding flags back into ecx

	asm("sub ecx, ebp");			// subtract shift count from exponent

	asm("jc short subfpundflw");	// if borrow, underflow

	asm("cmp ecx, 0x10000");		// check if exponent 0

	asm("jnc roundfp");				// if not, jump to round result, else underflow

	// come here if underflow

	asm("subfpundflw:");			

	asm("and ecx, 1");				// set exponent to zero, leave sign

	asm("xor edx, edx");

	asm("xor ebx, ebx");

	asm("mov eax, -10");			// return KErrUnderflow

	asm("ret");

	// come here to return zero result

	asm("subfp0:");

	asm("xor ecx, ecx");			// set exponent to zero, positive sign

	asm("xor edx, edx");

	asm("xor ebx, ebx");

	asm("addfp0snzd:");

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	// come here if source=0 - eax=source exponent/sign

	asm("addfp0s:");

	asm("cmp ecx, 0x10000");		// check if dest=0

	asm("jnc addfp0snzd");			// if not, return dest unaltered

	asm("and ecx, eax");			// else both zero, result negative iff both zeros negative

	asm("and ecx, 1");

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	// come here if dest=0, source nonzero

	asm("addfp0d:");

	asm("mov ebx, [esi]");			// return source unaltered

	asm("mov edx, [esi+4]");

	asm("mov ecx, [esi+8]");

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	// come here if dest=NaN or infinity

	asm("addfpsd:");

	asm("cmp edx, 0x80000000");		// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)		// branch if NaN

	asm("test ebx, ebx");

	_ASM_jn(e,TRealXBinOpNaN)

	asm("mov eax, [esi+8]");		// eax=second operand exponent

	asm("cmp eax, 0xFFFF0000");		// check second operand for NaN or infinity

	asm("jae short addfpsd1");		// branch if NaN or infinity

	asm("addfpsd2:");

	asm("mov eax, -9");				// else return dest unaltered [infinity] and KErrOverflow

	asm("ret");

	asm("addfpsd1:");

	asm("mov ebp, [esi]");			// source mantissa into edi:ebp

	asm("mov edi, [esi+4]");

	asm("cmp edi, 0x80000000");		// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)		// branch if NaN

	asm("test ebp, ebp");

	_ASM_jn(e,TRealXBinOpNaN)

	asm("xor al, cl");				// both operands are infinity - check signs

	asm("test al, 1");

	asm("jz short addfpsd2");		// if both the same, return KErrOverflow

	asm("jmp %a0": : "i"(&TRealXRealIndefinite));		// else return 'real indefinite'

	// come here if source=NaN or infinity, dest finite

	asm("addfpss:");

	asm("mov ebp, [esi]");			// source mantissa into edi:ebp

	asm("mov edi, [esi+4]");

	asm("cmp edi, 0x80000000");		// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)		// branch if NaN

	asm("test ebp, ebp");

	_ASM_jn(e,TRealXBinOpNaN)

	asm("mov ecx, eax");			// if source=infinity, return source unaltered

	asm("mov edx, edi");

	asm("mov ebx, ebp");

	asm("mov eax, -9");				// return KErrOverflow

	asm("ret");

	}

// Subtract TRealX at [esi] - ecx,edx:ebx

// Result in ecx,edx:ebx

// Error code in eax

LOCAL_C __NAKED__ void TRealXSubtract()

	{

	asm("xor cl, 1");				// negate subtrahend

	asm("jmp %a0": :"i"(&TRealXAdd));

	}

// Multiply TRealX at [esi] * ecx,edx:ebx

// Result in ecx,edx:ebx

// Error code in eax

LOCAL_C __NAKED__ void TRealXMultiply()

	{

	asm("xor ch, ch");				// clear rounding flags

	asm("mov eax, [esi+8]");		// fetch sign/exponent of source

	asm("xor cl, al");				// xor signs

	asm("cmp ecx, 0xFFFF0000");		// check if dest=NaN or infinity

	asm("jnc mulfpsd");				// branch if it is

	asm("cmp eax, 0xFFFF0000");		// check if source=NaN or infinity

	asm("jnc mulfpss");				// branch if it is

	asm("cmp eax, 0x10000");		// check if source=0

	asm("jc mulfp0");				// branch if it is

	asm("cmp ecx, 0x10000");		// check if dest=0

	asm("jc mulfp0");				// branch if it is

	asm("push ecx");				// save result sign

	asm("shr ecx, 16");				// dest exponent into cx

	asm("shr eax, 16");				// source exponent into ax

	asm("add eax, ecx");			// add exponents

	asm("sub eax, 0x7FFE");			// eax now contains result exponent

	asm("push eax");				// save it

	asm("mov edi, edx");			// save dest mantissa high

	asm("mov eax, ebx");			// dest mantissa low -> eax

	asm("mul dword ptr [esi]");		// dest mantissa low * source mantissa low -> edx:eax

	asm("xchg ebx, eax");			// result dword 0 -> ebx, dest mant low -> eax

	asm("mov ebp, edx");			// result dword 1 -> ebp

	asm("mul dword ptr [esi+4]");	// dest mant low * src mant high -> edx:eax

	asm("add ebp, eax");			// add in partial product to dwords 1 and 2

	asm("adc edx, 0");				//

	asm("mov ecx, edx");			// result dword 2 -> ecx

	asm("mov eax, edi");			// dest mant high -> eax

	asm("mul dword ptr [esi+4]");	// dest mant high * src mant high -> edx:eax

	asm("add ecx, eax");			// add in partial product to dwords 2, 3

	asm("adc edx, 0");				//

	asm("mov eax, edi");			// dest mant high -> eax

	asm("mov edi, edx");			// result dword 3 -> edi

	asm("mul dword ptr [esi]");		// dest mant high * src mant low -> edx:eax

	asm("add ebp, eax");			// add in partial product to dwords 1, 2

	asm("adc ecx, edx");			//

	asm("adc edi, 0");				// 128-bit mantissa product is now in edi:ecx:ebp:ebx

	asm("mov edx, edi");			// top 64 bits into edx:ebx

	asm("mov edi, ebx");			

	asm("mov ebx, ecx");			// bottom 64 bits now in ebp:edi

	asm("pop ecx");					// recover exponent

	asm("js short mulfp1");			// skip if mantissa normalised

	asm("add edi, edi");			// else shift left [only one shift will be needed]

	asm("adc ebp, ebp");

	asm("adc ebx, ebx");

	asm("adc edx, edx");

	asm("dec ecx");					// and decrement exponent

	asm("mulfp1:");

	asm("cmp ebp, 0x80000000");		// compare bottom 64 bits with 80000000 00000000 for rounding

	asm("ja short mulfp2");			// branch to round up

	asm("jb short mulfp3");			// branch to round down

	asm("test edi, edi");

	asm("jnz short mulfp2");		// branch to round up

	asm("test bl, 1");				// if exactly half-way, test LSB of result mantissa

	asm("jz short mulfp4");			// if LSB=0, round down [round to even]

	asm("mulfp2:");

	asm("add ebx, 1");				// round up - increment mantissa

	asm("adc edx, 0");

	asm("jnc short mulfp2a");

	asm("rcr edx, 1");

	asm("inc ecx");	

	asm("mulfp2a:");

	asm("mov al, 2");				// set rounded-up flag

	asm("jmp short mulfp5");

	asm("mulfp3:");					// round down

	asm("xor al, al");				// clear rounding flags

	asm("or ebp, edi");				// check for exact result

	asm("jz short mulfp5");			// skip if exact

	asm("mulfp4:");					// come here to round down when we know result inexact

	asm("mov al, 1");				// else set rounded-down flag

	asm("mulfp5:");					// final mantissa now in edx:ebx, exponent in ecx

	asm("cmp ecx, 0xFFFF");			// check for overflow

	asm("jge short mulfp6");		// branch if overflow

	asm("cmp ecx, 0");				// check for underflow

	asm("jle short mulfp7");		// branch if underflow

	asm("shl ecx, 16");				// else exponent up to top end of ecx

	asm("mov ch, al");				// rounding flags into ch

	asm("pop eax");					// recover result sign

	asm("mov cl, al");				// into cl

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	// come here if overflow

	asm("mulfp6:");					

	asm("pop eax");					// recover result sign

	asm("mov ecx, 0xFFFF0000");		// exponent=FFFF

	asm("mov cl, al");				// sign into cl

	asm("mov edx, 0x80000000");		// set mantissa to 80000000 00000000 for infinity

	asm("xor ebx, ebx");

	asm("mov eax, -9");				// return KErrOverflow

	asm("ret");

	// come here if underflow

	asm("mulfp7:");				

	asm("pop eax");					// recover result sign

	asm("xor ecx, ecx");			// exponent=0

	asm("mov cl, al");				// sign into cl

	asm("xor edx, edx");

	asm("xor ebx, ebx");

	asm("mov eax, -10");			// return KErrUnderflow

	asm("ret");

	// come here if either operand zero

	asm("mulfp0:");

	asm("and ecx, 1");				// set exponent=0, keep sign

	asm("xor edx, edx");

	asm("xor ebx, ebx");

	asm("xor eax, eax");			// return KErrNone

	asm("ret");

	// come here if destination operand NaN or infinity

	asm("mulfpsd:");

	asm("cmp edx, 0x80000000");		// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)		// branch if NaN

	asm("test ebx, ebx");

	_ASM_jn(e,TRealXBinOpNaN)

	asm("cmp eax, 0xFFFF0000");		// check second operand for NaN or infinity

	asm("jae short mulfpsd1");		// branch if NaN or infinity

	asm("cmp eax, 0x10000");		// check if second operand zero

	_ASM_j(c,TRealXRealIndefinite)	// if so, return 'real indefinite'

	asm("mov eax, -9");				// else return dest [infinity] with xor sign and KErrOverflow

	asm("ret");

	asm("mulfpsd1:");

	asm("mov ebp, [esi]");			// source mantissa into edi:ebp

	asm("mov edi, [esi+4]");		

	asm("cmp edi, 0x80000000");		// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)		// branch if NaN

	asm("test ebp, ebp");

	_ASM_jn(e,TRealXBinOpNaN)

	asm("mov eax, -9");				// both operands infinity - return infinity with xor sign

	asm("ret");						// and KErrOverflow

	// come here if source operand NaN or infinity, destination finite

	asm("mulfpss:");

	asm("mov ebp, [esi]");			// source mantissa into edi:ebp

	asm("mov edi, [esi+4]");

	asm("cmp edi, 0x80000000");		// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)		// branch if NaN

	asm("test ebp, ebp");

	_ASM_jn(e,TRealXBinOpNaN)

	asm("cmp ecx, 0x10000");		// source=infinity, check if dest=0

	_ASM_j(c,TRealXRealIndefinite)	// if so, return 'real indefinite'

	asm("or ecx, 0xFFFF0000");		// set exp=FFFF, leave xor sign in cl

	asm("mov edx, edi");			// set mantissa for infinity

	asm("mov ebx, ebp");

	asm("mov eax, -9");				// return KErrOverflow

	asm("ret");

	}

// Divide 96-bit unsigned dividend EDX:EAX:0 by 64-bit unsigned divisor ECX:EBX

// Assume ECX bit 31 = 1, ie 2^63 <= divisor < 2^64

// Assume the quotient fits in 32 bits

// Return 32 bit quotient in EDI

// Return 64 bit remainder in EBP:ESI

LOCAL_C __NAKED__ void LongDivide(void)

	{

	asm("push edx");				// save dividend

	asm("push eax");				//

	asm("cmp edx, ecx");			// check if truncation of divisor will overflow DIV instruction

	asm("jb short longdiv1");		// skip if not

	asm("xor eax, eax");			// else return quotient of 0xFFFFFFFF

	asm("dec eax");					//

	asm("jmp short longdiv2");		//

	asm("longdiv1:");

	asm("div ecx");					// divide EDX:EAX by ECX to give approximate quotient in EAX

	asm("longdiv2:");

	asm("mov edi, eax");			// save approx quotient