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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\euser\epoc\win32\uc_realx.cpp

// 

//

#include "u32std.h"

#include <e32math.h>

#pragma warning (disable : 4100)	// unreferenced formal parameter

#pragma warning (disable : 4700)	// local variable 'this' used without

									// having been initialised

#pragma warning ( disable : 4414 )  // short jump to function converted to near

#if defined(__VC32__) && (_MSC_VER==1100)	// untested on MSVC++ > 5.0

// Workaround for MSVC++ 5.0 bug; MSVC incorrectly fixes up conditional jumps

// when the destination is a C++ function.

#define _ASM_j(cond,dest) _asm jn##cond short $+11 _asm jmp dest

#define _ASM_jn(cond,dest) _asm j##cond short $+11 _asm jmp dest

#pragma optimize( "", off )			// stop MSVC murdering the code

#else

#define _ASM_j(cond,dest) _asm j##cond dest

#define _ASM_jn(cond,dest) _asm jn##cond dest

#endif

//

// 64-bit precision floating point routines

// Register storage format:

// edx:ebx=64 bit normalised mantissa

// ecx bits 16-31 = 16-bit exponent, biased by 7FFF

// ecx bit 0 = sign

// ecx bit 8 = rounded-down flag

// ecx bit 9 = rounded-up flag

//

// Memory storage format:

// 3 doublewords per number

// Low 32 bits of mantissa at [addr]

// High 32 bits of mantissa at [addr+4]

// Exponent/flags/sign at [addr+8]

//

LOCAL_C void TRealXPanic(TInt aErr)

	{

	User::Panic(_L("MATHX"),aErr);

	}

__NAKED__ LOCAL_C void TRealXPanicEax(void)

	{

	_asm push eax

	_asm call 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

	TRealXBinOpNaN1:			// swap the operands

	_asm xchg ecx, eax

	_asm xchg edx, edi

	_asm xchg ebx, ebp

	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

	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

	TRealXBinOpNaN5:			// come here if dest is smaller - copy source to dest

	_asm mov ecx, eax

	_asm mov edx, edi

	_asm mov ebx, ebp

	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

__NAKED__ LOCAL_C 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

	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

	addfp3a:

	_asm xor edi, edi			// clear edx:ebx

	_asm xor ebp, ebp

	_asm jmp short addfp5		// finished shifting

	addfp3b:					// exponents equal

	_asm xor eax, eax			// set rounding word=0

	_asm jmp short addfp5

	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

	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			//

	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

	addfp5a:

	_asm add ecx, 0x10000		// and increment exponent

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

	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)

	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

	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

	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

	roundfp0a:

	_asm xor eax, eax			// return KErrNone

	_asm ret					// exit

	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

	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

	addfp2a:

	_asm xor eax, eax			// return KErrNone

	_asm ret

	// signs differ, so must subtract mantissas

	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				//

	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

	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

	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

	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

	subfp0:

	_asm xor ecx, ecx			// set exponent to zero, positive sign

	_asm xor edx, edx

	_asm xor ebx, ebx

	addfp0snzd:

	_asm xor eax, eax			// return KErrNone

	_asm ret

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

	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

	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

	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

	addfpsd2:

	_asm mov eax, -9			// else return dest unaltered (infinity) and KErrOverflow

	_asm ret

	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 TRealXRealIndefinite	// else return 'real indefinite'

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

	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

__NAKED__ LOCAL_C void TRealXSubtract()

	{

	_asm xor cl, 1              // negate subtrahend

	_asm jmp TRealXAdd

	}

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

// Result in ecx,edx:ebx

// Error code in eax

__NAKED__ LOCAL_C 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

	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)

	mulfp2:

	_asm add ebx, 1				// round up - increment mantissa

	_asm adc edx, 0

	_asm jnc short mulfp2a

	_asm rcr edx, 1

	_asm inc ecx

	mulfp2a:

	_asm mov al, 2				// set rounded-up flag

	_asm jmp short mulfp5

	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

	mulfp4:						// come here to round down when we know result inexact

	_asm mov al, 1				// else set rounded-down flag

	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

	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

	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

	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

	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

	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

	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

__NAKED__ LOCAL_C 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		//

	longdiv1:

	_asm div ecx				// divide EDX:EAX by ECX to give approximate quotient in EAX

	longdiv2:

	_asm mov edi, eax			// save approx quotient

	_asm mul ebx				// multiply approx quotient by full divisor ECX:EBX

	_asm mov esi, eax			// first partial product into EBP:ESI

	_asm mov ebp, edx			//

	_asm mov eax, edi			// approx quotient back into eax

	_asm mul ecx				// upper partial product now in EDX:EAX

	_asm add eax, ebp			// add to form 96-bit product in EDX:EAX:ESI

	_asm adc edx, 0				//

	_asm neg esi				// remainder = dividend - approx quotient * divisor

	_asm mov ebp, [esp]			// fetch dividend bits 32-63

	_asm sbb ebp, eax			//

	_asm mov eax, [esp+4]		// fetch dividend bits 64-95

	_asm sbb eax, edx			// remainder is now in EAX:EBP:ESI

	_asm jns short longdiv4		// if remainder positive, quotient is correct, so exit

	longdiv3:

	_asm dec edi				// else quotient is too big, so decrement it

	_asm add esi, ebx			// and add divisor to remainder

	_asm adc ebp, ecx			//

	_asm adc eax, 0				//

	_asm js short longdiv3		// if still negative, repeat (requires <4 iterations)

	longdiv4:

	_asm add esp, 8				// remove dividend from stack

	_asm ret					// return with quotient in EDI, remainder in EBP:ESI

	}

// Divide TRealX at [esi] / ecx,edx:ebx

// Result in ecx,edx:ebx

// Error code in eax

__NAKED__ LOCAL_C void TRealXDivide(void)

	{

	_asm xor ch, ch				// clear rounding flags

	_asm mov eax, [esi+8]		// fetch sign/exponent of dividend

	_asm xor cl, al				// xor signs

	_asm cmp eax, 0xFFFF0000	// check if dividend=NaN or infinity

	_asm jnc divfpss			// branch if it is

	_asm cmp ecx, 0xFFFF0000	// check if divisor=NaN or infinity

	_asm jnc divfpsd			// branch if it is

	_asm cmp ecx, 0x10000		// check if divisor=0

	_asm jc divfpdv0			// branch if it is

	_asm cmp eax, 0x10000		// check if dividend=0

	_asm jc divfpdd0			// branch if it is

	_asm push esi				// save pointer to dividend

	_asm push ecx				// save result sign

	_asm shr ecx, 16			// divisor exponent into cx

	_asm shr eax, 16			// dividend exponent into ax

	_asm sub eax, ecx			// subtract exponents

	_asm add eax, 0x7FFE		// eax now contains result exponent

	_asm push eax				// save it

	_asm mov ecx, edx			// divisor mantissa into ecx:ebx

	_asm mov edx, [esi+4]		// dividend mantissa into edx:eax

	_asm mov eax, [esi]

	_asm xor edi, edi			// clear edi initially

	_asm cmp edx, ecx			// compare EDX:EAX with ECX:EBX

	_asm jb short divfp1		// if EDX:EAX < ECX:EBX, leave everything as is

	_asm ja short divfp2		//

	_asm cmp eax, ebx			// if EDX=ECX, then compare ls dwords

	_asm jb short divfp1		// if dividend mant < divisor mant, leave everything as is

	divfp2:

	_asm sub eax, ebx			// else dividend mant -= divisor mant

	_asm sbb edx, ecx			//

	_asm inc edi				// and EDI=1 (bit 0 of EDI is the integer part of the result)

	_asm inc dword ptr [esp]	// also increment result exponent

	divfp1:

	_asm push edi				// save top bit of result

	_asm call LongDivide		// divide EDX:EAX:0 by ECX:EBX to give next 32 bits of result in EDI

	_asm push edi				// save next 32 bits of result

	_asm mov edx, ebp			// remainder from EBP:ESI into EDX:EAX

	_asm mov eax, esi			//

	_asm call LongDivide		// divide EDX:EAX:0 by ECX:EBX to give next 32 bits of result in EDI

	_asm test byte ptr [esp+4], 1	// test integer bit of result

	_asm jnz short divfp4		// if set, no need to calculate another bit

	_asm xor eax, eax			//

	_asm add esi, esi			// 2*remainder into EAX:EBP:ESI

	_asm adc ebp, ebp			//

	_asm adc eax, eax			//

	_asm sub esi, ebx			// subtract divisor to generate final quotient bit

	_asm sbb ebp, ecx			//

	_asm sbb eax, 0				//

	_asm jnc short divfp3		// skip if no borrow - in this case eax=0

	_asm add esi, ebx			// if borrow add back - final remainder now in EBP:ESI

	_asm adc ebp, ecx			//

	_asm adc eax, 0				// eax will be zero after this and carry will be set

	divfp3:

	_asm cmc					// final bit = 1-C

	_asm rcr eax, 1				// shift it into eax bit 31

	_asm mov ebx, edi			// result into EDX:EBX:EAX, remainder in EBP:ESI

	_asm pop edx

	_asm add esp, 4				// discard integer bit (zero)

	_asm jmp short divfp5		// branch to round

	divfp4:						// integer bit was set

	_asm mov ebx, edi			// result into EDX:EBX:EAX

	_asm pop edx				//

	_asm pop eax				// integer part of result into eax (=1)

	_asm stc					// shift a 1 into top end of mantissa

	_asm rcr edx,1				//

	_asm rcr ebx,1				//

	_asm rcr eax,1				// bottom bit into eax bit 31

	// when we get to here we have 65 bits of quotient mantissa in

	// EDX:EBX:EAX (bottom bit in eax bit 31)

	// and the remainder is in EBP:ESI

	divfp5:

	_asm pop ecx				// recover result exponent

	_asm add eax, eax			// test rounding bit

	_asm jnc short divfp6		// branch to round down

	_asm or ebp, esi			// test remainder to see if we are exactly half-way

	_asm jnz short divfp7		// if not, round up

	_asm test bl, 1				// exactly halfway - test LSB of mantissa

	_asm jz short divfp8		// round down if LSB=0 (round to even)

	divfp7:

	_asm add ebx, 1				// round up - increment mantissa

	_asm adc edx, 0

	_asm jnc short divfp7a

	_asm rcr edx, 1				// if carry, shift 1 into mantissa MSB

	_asm inc ecx				// and increment exponent

	divfp7a:

	_asm mov al, 2				// set rounded-up flag

	_asm jmp short divfp9

	divfp6:

	_asm xor al, al				// round down - first clear rounding flags

	_asm or ebp, esi			// test if result exact

	_asm jz short divfp9		// skip if exact

	divfp8:						// come here to round down when we know result is inexact

	_asm mov al, 1				// set rounded-down flag

	divfp9:						// final mantissa now in edx:ebx, exponent in ecx

	_asm cmp ecx, 0xFFFF		// check for overflow

	_asm jge short divfp10		// branch if overflow

	_asm cmp ecx, 0				// check for underflow

	_asm jle short divfp11		// 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 pop esi				// recover dividend pointer

	_asm xor eax, eax			// return KErrNone

	_asm ret

	// come here if overflow

	divfp10:

	_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 pop esi				// recover dividend pointer

	_asm ret

	// come here if underflow

	divfp11:

	_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 pop esi				// recover dividend pointer

	_asm ret

	// come here if divisor=0, dividend finite

	divfpdv0:

	_asm cmp eax, 0x10000		// check if dividend also zero

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

	_asm or ecx, 0xFFFF0000		// else set exponent=FFFF, leave xor sign in cl

	_asm mov edx, 0x80000000	// set mantissa for infinity

	_asm xor ebx, ebx

	_asm mov eax, -41			// return KErrDivideByZero

	_asm ret

	// come here if dividend=0, divisor finite and nonzero

	divfpdd0:

	_asm and ecx, 1				// exponent=0, leave xor sign in cl

	_asm xor eax, eax			// return KErrNone

	_asm ret

	// come here if dividend is a NaN or infinity

	divfpss:

	_asm mov ebp, [esi]			// dividend 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, 0xFFFF0000	// check divisor for NaN or infinity

	_asm jae short divfpss1		// branch if NaN or infinity

	_asm or ecx, 0xFFFF0000		// infinity/finite - return infinity with xor sign

	_asm mov edx, 0x80000000

	_asm xor ebx, ebx

	_asm mov eax, -9			// return KErrOverflow

	_asm ret

	divfpss1:

	_asm cmp edx, 0x80000000	// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

	_asm test ebx, ebx

	_ASM_jn(e,TRealXBinOpNaN)

	_asm jmp TRealXRealIndefinite	// if both operands infinite, return 'real indefinite'

	// come here if divisor is a NaN or infinity, dividend finite

	divfpsd:

	_asm cmp edx, 0x80000000	// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

	_asm test ebx, ebx

	_ASM_jn(e,TRealXBinOpNaN)

	_asm and ecx, 1				// dividend is finite, divisor=infinity, so return 0 with xor sign

	_asm xor edx, edx

	_asm xor ebx, ebx

	_asm xor eax, eax			// return KErrNone

	_asm ret

	}

// TRealX modulo - dividend at [esi], divisor in ecx,edx:ebx

// Result in ecx,edx:ebx

// Error code in eax

__NAKED__ LOCAL_C void TRealXModulo(void)

	{

	_asm mov eax, [esi+8]		// fetch sign/exponent of dividend

	_asm mov cl, al				// result sign=dividend sign

	_asm xor ch, ch				// clear rounding flags

	_asm cmp eax, 0xFFFF0000	// check if dividend=NaN or infinity

	_asm jnc modfpss			// branch if it is

	_asm cmp ecx, 0xFFFF0000	// check if divisor=NaN or infinity

	_asm jnc modfpsd			// branch if it is

	_asm cmp ecx, 0x10000		// check if divisor=0

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

	_asm shr eax, 16			// ax=dividend exponent

	_asm ror ecx, 16			// cx=divisor exponent

	_asm sub ax, cx				// ax=dividend exponent-divisor exponent

	_asm jc modfpdd0			// if dividend exponent is smaller, return dividend

	_asm cmp ax, 64				// check if exponents differ by >= 64 bits

	_asm jnc modfplp			// if so, underflow

	_asm mov ah, 0				// ah bit 0 acts as 65th accumulator bit

	_asm mov ebp, [esi]			// edi:ebp=dividend mantissa

	_asm mov edi, [esi+4]		//

	_asm jmp short modfp2		// skip left shift on first iteration

	modfp1:

	_asm add ebp, ebp			// shift accumulator left (65 bits)

	_asm adc edi, edi

	_asm adc ah, ah

	modfp2:

	_asm sub ebp, ebx			// subtract divisor from dividend

	_asm sbb edi, edx

	_asm sbb ah, 0

	_asm jnc short modfp3		// skip if no borrow

	_asm add ebp, ebx			// else add back

	_asm adc edi, edx

	_asm adc ah, 0

	modfp3:

	_asm dec al					// any more bits to do?

	_asm jns short modfp1		// loop if there are

	_asm mov edx, edi			// result mantissa (not yet normalised) into edx:ebx

	_asm mov ebx, ebp

	_asm or edi, ebx			// check for zero

	_asm jz modfp0				// jump if result zero

	_asm or edx, edx			// check if ms dword zero

	_asm jnz short modfp4

	_asm mov edx, ebx			// if so, shift left by 32

	_asm xor ebx, ebx

	_asm sub cx, 32				// and decrement exponent by 32

	_asm jbe modfpund			// if borrow or exponent zero, underflow

	modfp4:

	_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 left by cl bits

	_asm shl ebx, cl			//

	_asm mov ebp, ecx			// bit count into ebp for subtraction

	_asm mov ecx, edi			// exponent & sign back into ecx

	_asm sub cx, bp				// subtract shift count from exponent

	_asm jbe short modfpund		// if borrow or exponent 0, underflow

	_asm rol ecx, 16			// else ecx=exponent:sign

	_asm xor eax, eax			// normal exit, result in ecx,edx:ebx

	_asm ret

	// dividend=NaN or infinity

	modfpss:

	_asm mov ebp, [esi]			// dividend 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, 0xFFFF0000	// check divisor for NaN or infinity

	_ASM_j(b,TRealXRealIndefinite)	// infinity%finite - return 'real indefinite'

	_asm cmp edx, 0x80000000	// check for divisor=infinity

	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

	_asm test ebx, ebx

	_ASM_jn(e,TRealXBinOpNaN)

	_asm jmp TRealXRealIndefinite	// if both operands infinite, return 'real indefinite'

	// divisor=NaN or infinity, dividend finite

	modfpsd:

	_asm cmp edx, 0x80000000	// check for infinity

	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

	_asm test ebx, ebx

	_ASM_jn(e,TRealXBinOpNaN)

	// finite%infinity - return dividend unaltered

	modfpdd0:

	_asm mov ebx, [esi]			// normal exit, return dividend unaltered

	_asm mov edx, [esi+4]

	_asm mov ecx, [esi+8]

	_asm xor eax, eax

	_asm ret

	modfp0:

	_asm shr ecx, 16			// normal exit, result 0

	_asm xor eax, eax

	_asm ret

	modfpund:

	_asm shr ecx, 16			// underflow, result 0

	_asm mov eax, -10			// return KErrUnderflow

	_asm ret

	modfplp:

	_asm shr ecx, 16			// loss of precision, result 0

	_asm mov eax, -7			// return KErrTotalLossOfPrecision

	_asm ret

	}

__NAKED__ EXPORT_C TRealX::TRealX()

/**

Constructs a default extended precision object.

This sets the value to zero.

*/

	{

	_asm xor eax, eax

	_asm mov [ecx], eax			// set value to zero

	_asm mov [ecx+4], eax

	_asm mov [ecx+8], eax

	_asm mov eax, ecx			// must return this

	_asm ret

	}

__NAKED__ EXPORT_C TRealX::TRealX(TUint /*aExp*/, TUint /*aMantHi*/, TUint /*aMantLo*/)

/**

Constructs an extended precision object from an explicit exponent and

a 64 bit mantissa.

@param aExp    The exponent 

@param aMantHi The high order 32 bits of the 64 bit mantissa 

@param aMantLo The low order 32 bits of the 64 bit mantissa 

*/

	{

	_asm mov eax, [esp+4]		// eax=aExp

	_asm mov [ecx+8], eax

	_asm mov eax, [esp+8]		// eax=aMantHi

	_asm mov [ecx+4], eax

	_asm mov eax, [esp+12]		// eax=aMantLo

	_asm mov [ecx], eax

	_asm mov eax, ecx			// must return this

	_asm ret 12

	}

__NAKED__ EXPORT_C TInt TRealX::Set(TInt /*aInt*/)

/**

Gives this extended precision object a new value taken

from a signed integer.

@param aInt The signed integer value.

@return KErrNone, always.

*/

	{

	// on entry ecx=this, [esp+4]=aInt, return code in eax

	_asm mov edx, [esp+4]		// edx=aInt

	_asm or edx, edx			// test sign/zero

	_asm mov eax, 0x7FFF

	_asm jz short trealxfromint0	// branch if 0

	_asm jns short trealxfromint1	// skip if positive

	_asm neg edx					// take absolute value

	_asm add eax, 0x10000			// sign bit in eax bit 16

	trealxfromint1:

	_asm push ecx					// save this

	_asm bsr ecx, edx				// bit number of edx MSB into ecx

	_asm add eax, ecx				// add to eax to form result exponent

	_asm neg cl

	_asm add cl, 31					// 31-bit number = number of shifts to normalise edx

	_asm shl edx, cl				// normalise edx

	_asm pop ecx					// this back into ecx

	_asm ror eax, 16				// sign/exponent into normal positions

	_asm mov [ecx+4], edx			// store mantissa high word

	_asm mov [ecx+8], eax			// store sign/exponent

	_asm xor eax, eax

	_asm mov [ecx], eax				// zero mantissa low word

	_asm ret 4						// return KErrNone

	trealxfromint0:

	_asm mov [ecx], edx

	_asm mov [ecx+4], edx			// store mantissa high word=0

	_asm mov [ecx+8], edx			// store sign/exponent=0

	_asm xor eax, eax				// return KErrNone

	_asm ret 4

	}

__NAKED__ EXPORT_C TInt TRealX::Set(TUint /*aInt*/)

/**

Gives this extended precision object a new value taken from

an unsigned integer.

@param aInt The unsigned integer value.

@return KErrNone, always.

*/

	{

	// on entry ecx=this, [esp+4]=aInt, return code in eax

	_asm mov edx, [esp+4]		// edx=aInt

	_asm mov eax, 0x7FFF

	_asm or edx, edx				// test for 0

	_asm jz short trealxfromuint0	// branch if 0

	_asm push ecx					// save this

	_asm bsr ecx, edx				// bit number of edx MSB into ecx

	_asm add eax, ecx				// add to eax to form result exponent

	_asm neg cl

	_asm add cl, 31					// 31-bit number = number of shifts to normalise edx

	_asm shl edx, cl				// normalise edx

	_asm pop ecx					// this back into ecx

	_asm shl eax, 16				// exponent into normal position