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