diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kernel/eka/euser/epoc/win32/uc_realx.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/kernel/eka/euser/epoc/win32/uc_realx.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,3281 @@ +// 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 + +#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 + _asm mov [ecx+4], edx // store mantissa high word + _asm mov [ecx+8], eax // store exponent + _asm xor eax, eax + _asm mov [ecx], eax // zero mantissa low word + _asm ret 4 // return KErrNone + trealxfromuint0: + _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__ LOCAL_C void TRealXFromTInt64(void) + { + // Convert TInt64 in edx:ebx to TRealX in ecx,edx:ebx + _asm mov eax, 0x7FFF + _asm or edx, edx // test sign/zero + _asm jz short trealxfromtint64a // branch if top word zero + _asm jns short trealxfromtint64b + _asm add eax, 0x10000 // sign bit into eax bit 16 + _asm neg edx // take absolute value + _asm neg ebx + _asm sbb edx, 0 + _asm jz short trealxfromtint64d // branch if top word zero + trealxfromtint64b: + _asm bsr ecx, edx // ecx=bit number of edx MSB + _asm add eax, ecx // add to exponent in eax + _asm add eax, 32 + _asm neg cl + _asm add cl, 31 // 31-bit number = number of left shifts to normalise + _asm shld edx, ebx, cl // shift left to normalise edx:ebx + _asm shl ebx, cl + _asm mov ecx, eax // sign/exponent into ecx + _asm ror ecx, 16 // and into normal positions + _asm ret + trealxfromtint64a: // come here if top word zero + _asm or ebx, ebx // test for bottom word also zero + _asm jz short trealxfromtint64c // branch if it is + trealxfromtint64d: // come here if top word zero, bottom word not + _asm mov edx, ebx // shift edx:ebx left 32 + _asm xor ebx, ebx + _asm bsr ecx, edx // ecx=bit number of edx MSB + _asm add eax, ecx // add to exponent in eax + _asm neg cl + _asm add cl, 31 // 31-bit number = number of left shifts to normalise + _asm shl edx, cl // normalise + _asm mov ecx, eax // sign/exponent into ecx + _asm ror ecx, 16 // and into normal positions + _asm ret + trealxfromtint64c: // entire number is zero + _asm xor ecx, ecx + _asm ret + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Set(const TInt64& /*aInt*/) +/** +Gives this extended precision object a new value taken from +a 64 bit integer. + +@param aInt The 64 bit integer value. + +@return KErrNone, always. +*/ + { + // on entry ecx=this, [esp+4]=address of aInt, return code in eax + _asm push ebx + _asm push ecx + _asm mov edx, [esp+12] // edx=address of aInt + _asm mov ebx, [edx] + _asm mov edx, [edx+4] // edx:ebx=aInt + _asm call TRealXFromTInt64 // convert to TRealX in ecx,edx:ebx + _asm pop eax // eax=this + _asm mov [eax], ebx // store result + _asm mov [eax+4], edx + _asm mov [eax+8], ecx + _asm xor eax, eax // return KErrNone + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ LOCAL_C void __6TRealXi() + { + // common function for int to TRealX + _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 mov eax, ecx // return eax=this + _asm ret 4 + 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 mov eax, ecx // return eax=this + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C TRealX::TRealX(TInt /*aInt*/) +/** +Constructs an extended precision object from a signed integer value. + +@param aInt The signed integer value. +*/ + { + // on entry ecx=this, [esp+4]=aInt, return eax=this + _asm jmp __6TRealXi + } + + + + +__NAKED__ EXPORT_C TRealX& TRealX::operator=(TInt /*aInt*/) +/** +Assigns the specified signed integer value to this extended precision object. + +@param aInt The signed integer value. + +@return A reference to this extended precision object. +*/ + { + // on entry ecx=this, [esp+4]=aInt, return eax=this + _asm jmp __6TRealXi + } + + + + +__NAKED__ LOCAL_C void __6TRealXui() + { + // common function for unsigned int to TRealX + _asm mov edx, [esp+4] // edx=aInt + _asm mov eax, 0x7FFF + _asm or edx, edx // test for zero + _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 + _asm mov [ecx+4], edx // store mantissa high word + _asm mov [ecx+8], eax // store exponent + _asm xor eax, eax + _asm mov [ecx], eax // zero mantissa low word + _asm mov eax, ecx // return eax=this + _asm ret 4 + trealxfromuint0: + _asm mov [ecx], edx + _asm mov [ecx+4], edx // store mantissa high word=0 + _asm mov [ecx+8], edx // store sign/exponent=0 + _asm mov eax, ecx // return eax=this + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C TRealX::TRealX(TUint /*aInt*/) +/** +Constructs an extended precision object from an unsigned integer value. + +@param aInt The unsigned integer value. +*/ + { + // on entry ecx=this, [esp+4]=aInt, return eax=this + _asm jmp __6TRealXui + } + + + + +__NAKED__ EXPORT_C TRealX& TRealX::operator=(TUint /*aInt*/) +/** +Assigns the specified unsigned integer value to this extended precision object. + +@param aInt The unsigned integer value. + +@return A reference to this extended precision object. +*/ + { + // on entry ecx=this, [esp+4]=aInt, return eax=this + _asm jmp __6TRealXui + } + + + + +__NAKED__ LOCAL_C void __6TRealXRC6TInt64() + { + // common function for TInt64 to TRealX + _asm push ebx // preserve ebx + _asm push ecx // save this + _asm mov edx, [esp+12] // edx=address of aInt + _asm mov ebx, [edx] + _asm mov edx, [edx+4] // edx:ebx=aInt + _asm call TRealXFromTInt64 // convert to TRealX in ecx,edx:ebx + _asm pop eax // eax=this + _asm mov [eax], ebx // store result + _asm mov [eax+4], edx + _asm mov [eax+8], ecx + _asm pop ebx // restore ebx + _asm ret 4 // return this in eax + } + + + + +__NAKED__ EXPORT_C TRealX::TRealX(const TInt64& /*aInt*/) +/** +Constructs an extended precision object from a 64 bit integer. + +@param aInt A reference to a 64 bit integer. +*/ + { + // on entry ecx=this, [esp+4]=address of aInt, return eax=this + _asm jmp __6TRealXRC6TInt64 + } + + + + +__NAKED__ EXPORT_C TRealX& TRealX::operator=(const TInt64& /*aInt*/) +/** +Assigns the specified 64 bit integer value to this extended precision object. + +@param aInt A reference to a 64 bit integer. + +@return A reference to this extended precision object. +*/ + { + // on entry ecx=this, [esp+4]=address of aInt, return eax=this + _asm jmp __6TRealXRC6TInt64 + } + + + + +__NAKED__ LOCAL_C void ConvertTReal32ToTRealX(void) + { + // Convert TReal32 in edx to TRealX in ecx:edx,ebx + _asm xor ebx, ebx // mant low always zero + _asm mov eax, edx + _asm shr eax, 23 // exponent now in al, sign in ah bit 0 + _asm test al, al // check for denormal/zero + _asm jz short treal32totrealx2 // branch if denormal/zero + _asm xor ecx, ecx + _asm mov cl, al + _asm add ecx, 0x7F80 // bias exponent correctly for TRealX + _asm cmp al, 0xFF // check for infinity/NaN + _asm jnz short treal32totrealx1 // skip if neither + _asm mov cl, al // else set TRealX exponent to FFFF + _asm mov ch, al + treal32totrealx1: + _asm shl edx, 8 // left-justify mantissa in edx + _asm or edx, 0x80000000 // put in implied integer bit + _asm shl ecx, 16 // exponent into ecx bits 16-31 + _asm mov cl, ah // sign into ecx bit 0 + _asm ret + treal32totrealx2: // come here if exponent 0 + _asm shl edx, 9 // left-justify mantissa in edx (shift out integer bit as well) + _asm jnz short treal32totrealx3 // jump if denormal + _asm xor ecx, ecx // else return 0 + _asm mov cl, ah // with same sign as input value + _asm ret + treal32totrealx3: // come here if denormal + _asm bsr ecx, edx // ecx=bit number of MSB of edx + _asm neg ecx + _asm add ecx, 31 // ecx=number of left shifts to normalise edx + _asm shl edx, cl // normalise + _asm neg ecx + _asm add ecx, 0x7F80 // exponent=7F80-number of shifts + _asm shl ecx, 16 // exponent into ecx bits 16-31 + _asm mov cl, ah // sign into ecx bit 0 + _asm ret + } + +__NAKED__ LOCAL_C void ConvertTReal64ToTRealX(void) + { + // Convert TReal64 in edx:ebx to TRealX in ecx:edx,ebx + _asm mov eax, edx + _asm shr eax, 20 + _asm mov ecx, 0x7FF + _asm and ecx, eax // ecx=exponent + _asm jz short treal64totrealx1 // branch if zero/denormal + _asm add ecx, 0x7C00 // else bias exponent correctly for TRealX + _asm cmp ecx, 0x83FF // check for infinity/NaN + _asm jnz short treal64totrealx2 + _asm mov ch, cl // if so, set exponent to FFFF + treal64totrealx2: + _asm shl ecx, 16 // exponent into ecx bits 16-31 + _asm mov cl, 11 // number of shifts needed to justify mantissa correctly + _asm shld edx, ebx, cl // shift mantissa left + _asm shl ebx, cl + _asm or edx, 0x80000000 // put in implied integer bit + _asm shr eax, 11 // sign bit into al bit 0 + _asm mov cl, al // into ecx bit 0 + _asm ret + treal64totrealx1: // come here if zero/denormal + _asm mov cl, 12 // number of shifts needed to justify mantissa correctly + _asm shld edx, ebx, cl // shift mantissa left + _asm shl ebx, cl + _asm test edx, edx // check for zero + _asm jnz short treal64totrealx3 + _asm test ebx, ebx + _asm jnz short treal64totrealx4 + _asm shr eax, 11 // sign bit into eax bit 0, rest of eax=0 + _asm mov ecx, eax // return 0 result with correct sign + _asm ret + treal64totrealx4: // come here if denormal, edx=0 + _asm mov edx, ebx // shift mantissa left 32 + _asm xor ebx, ebx + _asm bsr ecx, edx // ecx=bit number of MSB of edx + _asm neg ecx + _asm add ecx, 31 // ecx=number of left shifts to normalise edx + _asm shl edx, cl // normalise + _asm neg ecx + _asm add ecx, 0x7BE0 // exponent=7BE0-number of shifts + _asm shl ecx, 16 // exponent into bits 16-31 of ecx + _asm shr eax, 11 + _asm mov cl, al // sign into bit 0 of ecx + _asm ret + treal64totrealx3: // come here if denormal, edx nonzero + _asm bsr ecx, edx // ecx=bit number of MSB of edx + _asm neg ecx + _asm add ecx, 31 // ecx=number of left shifts to normalise edx:ebx + _asm shld edx, ebx, cl // normalise + _asm shl ebx, cl + _asm neg ecx + _asm add ecx, 0x7C00 // exponent=7C00-number of shifts + _asm shl ecx, 16 // exponent into bits 16-31 of ecx + _asm shr eax, 11 + _asm mov cl, al // sign into bit 0 of ecx + _asm ret + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Set(TReal32 /*aReal*/) +/** +Gives this extended precision object a new value taken from +a single precision floating point number. + +@param aReal The single precision floating point value. + +@return KErrNone, if a valid number; + KErrOverflow, if the number is infinite; + KErrArgument, if not a number. +*/ + { + // on entry, ecx=this and aReal is in [esp+4] + // on exit, error code in eax + _asm push ebx // save ebx + _asm push ecx // save this + _asm mov edx, [esp+12] // aReal into edx + _asm call ConvertTReal32ToTRealX + _asm pop eax // eax=this + _asm mov [eax], ebx // store result + _asm mov [eax+4], edx + _asm mov [eax+8], ecx + _asm xor eax, eax // error code=KErrNone initially + _asm cmp ecx, 0xFFFF0000 // check for infinity/NaN + _asm jb short trealxsettreal32a // if neither, return KErrNone + _asm mov eax, -9 // eax=KErrOverflow + _asm cmp edx, 0x80000000 // check for infinity + _asm je short trealxsettreal32a // if infinity, return KErrOverflow + _asm mov eax, -6 // if NaN, return KErrArgument + trealxsettreal32a: + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Set(TReal64 /*aReal*/) +/** +Gives this extended precision object a new value taken from +a double precision floating point number. + +@param aReal The double precision floating point value. + +@return KErrNone, if a valid number; + KErrOverflow, if the number is infinite; + KErrArgument, if not a number. +*/ + { + // on entry, ecx=this and aReal is in [esp+4] (mant low) and [esp+8] (sign/exp/mant high) + // on exit, error code in eax + _asm push ebx // save ebx + _asm push ecx // save this + _asm mov ebx, [esp+12] // aReal into edx:ebx + _asm mov edx, [esp+16] + _asm call ConvertTReal64ToTRealX + _asm pop eax // eax=this + _asm mov [eax], ebx // store result + _asm mov [eax+4], edx + _asm mov [eax+8], ecx + _asm xor eax, eax // error code=KErrNone initially + _asm cmp ecx, 0xFFFF0000 // check for infinity/NaN + _asm jb short trealxsettreal64a // if neither, return KErrNone + _asm mov eax, -9 // eax=KErrOverflow + _asm cmp edx, 0x80000000 // check for infinity + _asm jne short trealxsettreal64b // branch if NaN + _asm test ebx, ebx + _asm je short trealxsettreal64a // if infinity, return KErrOverflow + trealxsettreal64b: + _asm mov eax, -6 // if NaN, return KErrArgument + trealxsettreal64a: + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ LOCAL_C void __6TRealXf() + { + // common function for float to TRealX + _asm push ebx // save ebx + _asm push ecx // save this + _asm mov edx, [esp+12] // aReal into edx + _asm call ConvertTReal32ToTRealX + _asm pop eax // eax=this + _asm mov [eax], ebx // store result + _asm mov [eax+4], edx + _asm mov [eax+8], ecx + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C TRealX::TRealX(TReal32 /*aReal*/) +/** +Constructs an extended precision object from +a single precision floating point number. + +@param aReal The single precision floating point value. +*/ + { + // on entry, ecx=this and aReal is in [esp+4] + // on exit, eax=this + _asm jmp __6TRealXf + } + + + + +__NAKED__ EXPORT_C TRealX& TRealX::operator=(TReal32 /*aReal*/) +/** +Assigns the specified single precision floating point number to +this extended precision object. + +@param aReal The single precision floating point value. + +@return A reference to this extended precision object. +*/ + { + // on entry, ecx=this and aReal is in [esp+4] + // on exit, eax=this + _asm jmp __6TRealXf + } + + + + +__NAKED__ LOCAL_C void __6TRealXd() + { + // common function for double to TRealX + _asm push ebx // save ebx + _asm push ecx // save this + _asm mov ebx, [esp+12] // aReal into edx:ebx + _asm mov edx, [esp+16] + _asm call ConvertTReal64ToTRealX + _asm pop eax // eax=this + _asm mov [eax], ebx // store result + _asm mov [eax+4], edx + _asm mov [eax+8], ecx + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TRealX::TRealX(TReal64 /*aReal*/) +/** +Constructs an extended precision object from +a double precision floating point number. + +@param aReal The double precision floating point value. +*/ + { + // on entry, ecx=this and aReal is in [esp+4] (mant low) and [esp+8] (sign/exp/mant high) + // on exit, eax=this + _asm jmp __6TRealXd + } + + + + +__NAKED__ EXPORT_C TRealX& TRealX::operator=(TReal64 /*aReal*/) +/** +Assigns the specified double precision floating point number to +this extended precision object. + +@param aReal The double precision floating point value. + +@return A reference to this extended precision object. +*/ + { + // on entry, ecx=this and aReal is in [esp+4] (mant low) and [esp+8] (sign/exp/mant high) + // on exit, eax=this + _asm jmp __6TRealXd + } + + + + +__NAKED__ EXPORT_C TRealX::operator TInt() const +/** +Gets the extended precision value as a signed integer value. + +The operator returns: + +1. zero , if the extended precision value is not a number + +2. 0x7FFFFFFF, if the value is positive and too big to fit into a TInt. + +3. 0x80000000, if the value is negative and too big to fit into a TInt. +*/ + { + // on entry ecx=this, return value in eax + _asm mov edx, [ecx] // edx=mantissa low + _asm mov eax, [ecx+4] // eax=mantissa high + _asm mov ecx, [ecx+8] // ecx=exponent/sign + _asm ror ecx, 16 // exponent into cx + _asm cmp cx, 0xFFFF + _asm jz short trealxtoint1 // branch if exp=FFFF + _asm mov dx, cx + _asm mov cx, 0x801E + _asm sub cx, dx // cx=number of right shifts needed to convert mantissa to int + _asm jbe short trealxtoint2 // if exp>=801E, saturate result + _asm cmp cx, 31 // more than 31 shifts needed? + _asm ja short trealxtoint0 // if so, underflow to zero + _asm shr eax, cl // else ABS(result)=eax>>cl + _asm test ecx, 0x10000 // test sign + _asm jz short trealxtoint3 // skip if + + _asm neg eax + trealxtoint3: + _asm ret + trealxtoint1: // come here if exponent=FFFF + _asm cmp eax, 0x80000000 // check for infinity + _asm jnz short trealxtoint0 // if NaN, return 0 + _asm test edx, edx + _asm jnz short trealxtoint0 // if NaN, return 0 + trealxtoint2: // come here if argument too big for 32-bit integer + _asm mov eax, 0x7FFFFFFF + _asm shr ecx, 17 // sign bit into carry flag + _asm adc eax, 0 // eax=7FFFFFFF if +, 80000000 if - + _asm ret // return saturated value + trealxtoint0: // come here if INT(argument)=0 or NaN + _asm xor eax, eax // return 0 + _asm ret + } + + + + +__NAKED__ EXPORT_C TRealX::operator TUint() const +/** +Returns the extended precision value as an unsigned signed integer value. + +The operator returns: + +1. zero, if the extended precision value is not a number + +2. 0xFFFFFFFF, if the value is positive and too big to fit into a TUint. + +3. zero, if the value is negative and too big to fit into a TUint. +*/ + { + // on entry ecx=this, return value in eax + _asm mov edx, [ecx] // edx=mantissa low + _asm mov eax, [ecx+4] // eax=mantissa high + _asm mov ecx, [ecx+8] // ecx=exponent/sign + _asm ror ecx, 16 // exponent into cx + _asm cmp cx, 0xFFFF + _asm jz short trealxtouint1 // branch if exp=FFFF + _asm mov dx, cx + _asm mov cx, 0x801E + _asm sub cx, dx // cx=number of right shifts needed to convert mantissa to int + _asm jb short trealxtouint2 // if exp>801E, saturate result + _asm cmp cx, 31 // more than 31 shifts needed? + _asm ja short trealxtouint0 // if so, underflow to zero + _asm test ecx, 0x10000 // test sign + _asm jnz short trealxtouint0 // if -, return 0 + _asm shr eax, cl // else result=eax>>cl + _asm ret + trealxtouint1: // come here if exponent=FFFF + _asm cmp eax, 0x80000000 // check for infinity + _asm jnz short trealxtouint0 // if NaN, return 0 + _asm test edx, edx + _asm jnz short trealxtouint0 // if NaN, return 0 + trealxtouint2: // come here if argument too big for 32-bit integer + _asm mov eax, 0xFFFFFFFF + _asm shr ecx, 17 // sign bit into carry flag + _asm adc eax, 0 // eax=FFFFFFFF if +, 0 if - + _asm ret // return saturated value + trealxtouint0: // come here if INT(argument)=0 or NaN + _asm xor eax, eax // return 0 + _asm ret + } + + + + +__NAKED__ LOCAL_C void ConvertTRealXToTInt64(void) + { + // Convert TRealX in ecx,edx:ebx to TInt64 in edx:ebx + _asm ror ecx, 16 // exponent into cx + _asm cmp cx, 0xFFFF + _asm jz short trealxtoint64a // branch if exp=FFFF + _asm mov ax, cx + _asm mov cx, 0x803E + _asm sub cx, ax // cx=number of right shifts needed to convert mantissa to int + _asm jbe short trealxtoint64b // if exp>=803E, saturate result + _asm cmp cx, 63 // more than 63 shifts needed? + _asm ja short trealxtoint64z // if so, underflow to zero + _asm cmp cl, 31 // more than 31 shifts needed? + _asm jbe short trealxtoint64d // branch if not + _asm sub cl, 32 // cl=shift count - 32 + _asm mov ebx, edx // shift right by 32 + _asm xor edx, edx + trealxtoint64d: + _asm shrd ebx, edx, cl // shift edx:ebx right by cl to give ABS(result) + _asm shr edx, cl + _asm test ecx, 0x10000 // test sign + _asm jz short trealxtoint64c // skip if + + _asm neg edx // if -, negate + _asm neg ebx + _asm sbb edx, 0 + trealxtoint64c: + _asm ret + trealxtoint64a: // come here if exponent=FFFF + _asm cmp edx, 0x80000000 // check for infinity + _asm jnz short trealxtoint64z // if NaN, return 0 + _asm test ebx, ebx + _asm jnz short trealxtoint64z // if NaN, return 0 + trealxtoint64b: // come here if argument too big for 32-bit integer + _asm mov edx, 0x7FFFFFFF + _asm mov ebx, 0xFFFFFFFF + _asm shr ecx, 17 // sign bit into carry flag + _asm adc ebx, 0 // edx:ebx=7FFFFFFF FFFFFFFF if +, + _asm adc edx, 0 // or 80000000 00000000 if - + _asm ret // return saturated value + trealxtoint64z: // come here if INT(argument)=0 or NaN + _asm xor edx, edx // return 0 + _asm xor ebx, ebx + _asm ret + } + + + + +/** +Returns the extended precision value as a 64 bit integer value. + +The operator returns: + +1. zero, if the extended precision value is not a number + +2. 0x7FFFFFFF FFFFFFFF, if the value is positive and too big to fit + into a TInt64 + +3. 0x80000000 00000000, if the value is negative and too big to fit + into a TInt64. +*/ +__NAKED__ EXPORT_C TRealX::operator TInt64() const + { + // on entry, ecx=this, return value in edx:eax + _asm push ebx + _asm mov ebx, [ecx] // get TRealX value into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call ConvertTRealXToTInt64 + _asm mov eax, ebx // store low result into eax + _asm pop ebx + _asm ret + } + + + + +__NAKED__ LOCAL_C void TRealXGetTReal32(void) + { + // Convert TRealX in ecx,edx:ebx to TReal32 in edx + // Return error code in eax + _asm cmp ecx, 0xFFFF0000 // check for infinity/NaN + _asm jnc short trealxgettreal32a + _asm xor eax, eax + _asm ror ecx, 16 // exponent into cx + _asm sub cx, 0x7F80 // cx=result exponent if normalised + _asm jbe short trealxgettreal32b // jump if denormal, zero or underflow + _asm cmp cx, 0xFF // check if overflow + _asm jb short trealxgettreal32c // jump if not + trealxgettreal32d: // come here if overflow + _asm xor edx, edx // set mantissa=0 to generate infinity + _asm ror ecx, 16 // ecx back to normal format + trealxgettreal32a: // come here if infinity or NaN + _asm shr edx, 7 + _asm or edx, 0xFF000000 // set exponent to FF + _asm shr ecx, 1 // sign bit -> carry + _asm rcr edx, 1 // sign bit -> MSB of result + _asm mov eax, edx + _asm shl eax, 9 // test for infinity or NaN + _asm mov eax, -9 // eax=KErrOverflow + _asm jz short trealxgettreal32e + _asm mov eax, -6 // if NaN, eax=KErrArgument + trealxgettreal32e: + _asm ret + trealxgettreal32b: // come here if exponent<=7F80 + _asm cmp cx, -24 // check for zero or total underflow + _asm jle short trealxgettreal32z + _asm neg cl + _asm inc cl // cl=number of right shifts to form denormal mantissa + _asm shrd eax, ebx, cl // shift mantissa right into eax + _asm shrd ebx, edx, cl + _asm shr edx, cl + _asm or edx, 0x80000000 // set top bit to ensure correct rounding up + _asm xor cl, cl // cl=result exponent=0 + trealxgettreal32c: // come here if result normalised + _asm cmp dl, 0x80 // check rounding bits + _asm ja short trealxgettreal32f // branch to round up + _asm jb short trealxgettreal32g // branch to round down + _asm test ebx, ebx + _asm jnz short trealxgettreal32f // branch to round up + _asm test eax, eax + _asm jnz short trealxgettreal32f // branch to round up + _asm test ecx, 0x01000000 // check rounded-down flag + _asm jnz short trealxgettreal32f // branch to round up + _asm test ecx, 0x02000000 // check rounded-up flag + _asm jnz short trealxgettreal32g // branch to round down + _asm test dh, 1 // else round to even + _asm jz short trealxgettreal32g // branch to round down if LSB=0 + trealxgettreal32f: // come here to round up + _asm add edx, 0x100 // increment mantissa + _asm jnc short trealxgettreal32g + _asm rcr edx, 1 + _asm inc cl // if carry, increment exponent + _asm cmp cl, 0xFF // and check for overflow + _asm jz short trealxgettreal32d // branch out if overflow + trealxgettreal32g: // come here to round down + _asm xor dl, dl + _asm add edx, edx // shift out integer bit + _asm mov dl, cl + _asm ror edx, 8 // exponent->edx bits 24-31, mantissa in 23-1 + _asm test edx, edx // check if underflow + _asm jz short trealxgettreal32h // branch out if underflow + _asm shr ecx, 17 // sign bit->carry + _asm rcr edx, 1 // ->edx bit 31, exp->edx bits 23-30, mant->edx bits 22-0 + _asm xor eax, eax // return KErrNone + _asm ret + trealxgettreal32z: // come here if zero or underflow + _asm xor eax, eax + _asm cmp cx, 0x8080 // check for zero + _asm jz short trealxgettreal32y // if zero, return KErrNone + trealxgettreal32h: // come here if underflow after rounding + _asm mov eax, -10 // eax=KErrUnderflow + trealxgettreal32y: + _asm xor edx, edx + _asm shr ecx, 17 + _asm rcr edx, 1 // sign bit into edx bit 31, rest of edx=0 + _asm ret + } + + + + +__NAKED__ LOCAL_C void TRealXGetTReal64(void) + { + // Convert TRealX in ecx,edx:ebx to TReal64 in edx:ebx + // Return error code in eax + // edi, esi also modified + _asm ror ecx, 16 // exponent into cx + _asm cmp cx, 0xFFFF // check for infinity/NaN + _asm jnc short trealxgettreal64a + _asm xor eax, eax + _asm xor edi, edi + _asm sub cx, 0x7C00 // cx=result exponent if normalised + _asm jbe short trealxgettreal64b // jump if denormal, zero or underflow + _asm cmp cx, 0x07FF // check if overflow + _asm jb short trealxgettreal64c // jump if not + trealxgettreal64d: // come here if overflow + _asm xor edx, edx // set mantissa=0 to generate infinity + _asm xor ebx, ebx + trealxgettreal64a: // come here if infinity or NaN + _asm mov cl, 10 + _asm shrd ebx, edx, cl + _asm shr edx, cl + _asm or edx, 0xFFE00000 // set exponent to 7FF + _asm shr ecx, 17 // sign bit -> carry + _asm rcr edx, 1 // sign bit -> MSB of result + _asm rcr ebx, 1 + _asm mov eax, edx + _asm shl eax, 12 // test for infinity or NaN + _asm mov eax, -9 // eax=KErrOverflow + _asm jnz short trealxgettreal64n + _asm test ebx, ebx + _asm jz short trealxgettreal64e + trealxgettreal64n: + _asm mov eax, -6 // if NaN, eax=KErrArgument + trealxgettreal64e: + _asm ret + trealxgettreal64b: // come here if exponent<=7C00 + _asm cmp cx, -53 // check for zero or total underflow + _asm jle trealxgettreal64z + _asm neg cl + _asm inc cl // cl=number of right shifts to form denormal mantissa + _asm cmp cl, 32 + _asm jb trealxgettreal64x + _asm mov eax, ebx // if >=32 shifts, do 32 shifts and decrement count by 32 + _asm mov ebx, edx + _asm xor edx, edx + trealxgettreal64x: + _asm shrd edi, eax, cl + _asm shrd eax, ebx, cl // shift mantissa right into eax + _asm shrd ebx, edx, cl + _asm shr edx, cl + _asm or edx, 0x80000000 // set top bit to ensure correct rounding up + _asm xor cx, cx // cx=result exponent=0 + trealxgettreal64c: // come here if result normalised + _asm mov esi, ebx + _asm and esi, 0x7FF // esi=rounding bits + _asm cmp esi, 0x400 // check rounding bits + _asm ja short trealxgettreal64f // branch to round up + _asm jb short trealxgettreal64g // branch to round down + _asm test eax, eax + _asm jnz short trealxgettreal64f // branch to round up + _asm test edi, edi + _asm jnz short trealxgettreal64f // branch to round up + _asm test ecx, 0x01000000 // check rounded-down flag + _asm jnz short trealxgettreal64f // branch to round up + _asm test ecx, 0x02000000 // check rounded-up flag + _asm jnz short trealxgettreal64g // branch to round down + _asm test ebx, 0x800 // else round to even + _asm jz short trealxgettreal64g // branch to round down if LSB=0 + trealxgettreal64f: // come here to round up + _asm add ebx, 0x800 // increment mantissa + _asm adc edx, 0 + _asm jnc short trealxgettreal64g + _asm rcr edx, 1 + _asm inc cx // if carry, increment exponent + _asm cmp cx, 0x7FF // and check for overflow + _asm jz trealxgettreal64d // branch out if overflow + trealxgettreal64g: // come here to round down + _asm xor bl, bl // clear rounding bits + _asm and bh, 0xF8 + _asm mov di, cx // save exponent + _asm mov cl, 10 + _asm and edx, 0x7FFFFFFF // clear integer bit + _asm shrd ebx, edx, cl // shift mantissa right by 10 + _asm shr edx, cl + _asm shl edi, 21 // exponent into edi bits 21-31 + _asm or edx, edi // into edx bits 21-31 + _asm test edx, edx // check if underflow + _asm jnz short trealxgettreal64i + _asm test ebx, ebx + _asm jz short trealxgettreal64h // branch out if underflow + trealxgettreal64i: + _asm shr ecx, 17 // sign bit->carry + _asm rcr edx, 1 // ->edx bit 31, exp->edx bits 20-30, mant->edx bits 20-0 + _asm rcr ebx, 1 + _asm xor eax, eax // return KErrNone + _asm ret + trealxgettreal64z: // come here if zero or underflow + _asm xor eax, eax + _asm cmp cx, 0x8400 // check for zero + _asm jz short trealxgettreal64y // if zero, return KErrNone + trealxgettreal64h: // come here if underflow after rounding + _asm mov eax, -10 // eax=KErrUnderflow + trealxgettreal64y: + _asm xor edx, edx + _asm xor ebx, ebx + _asm shr ecx, 17 + _asm rcr edx, 1 // sign bit into edx bit 31, rest of edx=0, ebx=0 + _asm ret + } + + + + +__NAKED__ EXPORT_C TRealX::operator TReal32() const +/** +Returns the extended precision value as +a single precision floating point value. +*/ + { + // On entry, ecx=this + // On exit, TReal32 value on top of FPU stack + _asm push ebx + _asm mov ebx, [ecx] // *this into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXGetTReal32 // Convert to TReal32 in edx + _asm push edx // push TReal32 onto stack + _asm fld dword ptr [esp] // push TReal32 onto FPU stack + _asm pop edx + _asm pop ebx + _asm ret + } + + + + +__NAKED__ EXPORT_C TRealX::operator TReal64() const +/** +Returns the extended precision value as +a double precision floating point value. +*/ + { + // On entry, ecx=this + // On exit, TReal64 value on top of FPU stack + _asm push ebx + _asm push esi + _asm push edi + _asm mov ebx, [ecx] // *this into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXGetTReal64 // Convert to TReal32 in edx:ebx + _asm push edx // push TReal64 onto stack + _asm push ebx + _asm fld qword ptr [esp] // push TReal64 onto FPU stack + _asm add esp, 8 + _asm pop edi + _asm pop esi + _asm pop ebx + _asm ret + } + + + + +__NAKED__ EXPORT_C TInt TRealX::GetTReal(TReal32& /*aVal*/) const +/** +Extracts the extended precision value as +a single precision floating point value. + +@param aVal A reference to a single precision object which contains + the result of the operation. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow. +*/ + { + // On entry, ecx=this, [esp+4]=address of aVal + // On exit, eax=return code + _asm push ebx + _asm mov ebx, [ecx] // *this into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXGetTReal32 + _asm mov ecx, [esp+8] // ecx=address of aVal + _asm mov [ecx], edx // store result + _asm pop ebx + _asm ret 4 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::GetTReal(TReal64& /*aVal*/) const +/** +Extracts the extended precision value as +a double precision floating point value. + +@param aVal A reference to a double precision object which + contains the result of the operation. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow. +*/ + { + // On entry, ecx=this, [esp+4]=address of aVal + // On exit, eax=return code + _asm push ebx + _asm push esi + _asm push edi + _asm mov ebx, [ecx] // *this into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXGetTReal64 + _asm mov ecx, [esp+16] // ecx=address of aVal + _asm mov [ecx], ebx // store result + _asm mov [ecx+4], edx + _asm pop edi + _asm pop esi + _asm pop ebx + _asm ret 4 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C void TRealX::SetZero(TBool /*aNegative*/) +/** +Sets the value of this extended precision object to zero. + +@param aNegative ETrue, the value is a negative zero; + EFalse, the value is a positive zero, this is the default. +*/ + { + _asm mov edx, [esp+4] // aNegative into edx + _asm xor eax, eax // eax=0 + _asm mov [ecx], eax + _asm mov [ecx+4], eax + _asm test edx, edx + _asm jz short setzero1 + _asm inc eax // eax=1 if aNegative!=0 + setzero1: + _asm mov [ecx+8], eax // generate positive or negative zero + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C void TRealX::SetNaN() +/** +Sets the value of this extended precision object to 'not a number'. +*/ + { + _asm xor eax, eax // set *this to 'real indefinite' + _asm mov [ecx], eax + _asm mov eax, 0xC0000000 + _asm mov [ecx+4], eax + _asm mov eax, 0xFFFF0001 + _asm mov [ecx+8], eax + _asm ret + } + + + + +__NAKED__ EXPORT_C void TRealX::SetInfinite(TBool /*aNegative*/) +/** +Sets the value of this extended precision object to infinity. + +@param aNegative ETrue, the value is a negative zero; + EFalse, the value is a positive zero. +*/ + { + _asm mov edx, [esp+4] // aNegative into edx + _asm mov eax, 0xFFFF0000 // exponent=FFFF, sign=0 initially + _asm test edx, edx + _asm jz short setinf1 + _asm inc eax // sign=1 if aNegative!=0 + setinf1: + _asm mov [ecx+8], eax // generate positive or negative infinity + _asm mov eax, 0x80000000 + _asm mov [ecx+4], eax + _asm xor eax, eax + _asm mov [ecx], eax + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C TBool TRealX::IsZero() const +/** +Determines whether the extended precision value is zero. + +@return True, if the extended precision value is zero, false, otherwise. +*/ + { + _asm mov eax, [ecx+8] // check exponent + _asm shr eax, 16 // move exponent into ax + _asm jz short iszero1 // branch if zero + _asm xor eax, eax // else return 0 + _asm ret + iszero1: + _asm inc eax // if zero, return 1 + _asm ret + } + + + + +__NAKED__ EXPORT_C TBool TRealX::IsNaN() const +/** +Determines whether the extended precision value is 'not a number'. + +@return True, if the extended precision value is 'not a number', + false, otherwise. +*/ + { + _asm mov eax, [ecx+8] // check exponent + _asm cmp eax, 0xFFFF0000 + _asm jc short isnan0 // branch if not FFFF + _asm mov eax, [ecx+4] + _asm cmp eax, 0x80000000 // check for infinity + _asm jne short isnan1 + _asm mov eax, [ecx] + _asm test eax, eax + _asm jne short isnan1 + isnan0: + _asm xor eax, eax // return 0 if not NaN + _asm ret + isnan1: + _asm mov eax, 1 // return 1 if NaN + _asm ret + } + + + + +__NAKED__ EXPORT_C TBool TRealX::IsInfinite() const +/** +Determines whether the extended precision value has a finite value. + +@return True, if the extended precision value is finite, + false, if the value is 'not a number' or is infinite, +*/ + { + _asm mov eax, [ecx+8] // check exponent + _asm cmp eax, 0xFFFF0000 + _asm jc short isinf0 // branch if not FFFF + _asm mov eax, [ecx+4] + _asm cmp eax, 0x80000000 // check for infinity + _asm jne short isinf0 + _asm mov eax, [ecx] + _asm test eax, eax + _asm jne short isinf0 + _asm inc eax // return 1 if infinity + _asm ret + isinf0: + _asm xor eax, eax // return 0 if not infinity + _asm ret + } + + + + +__NAKED__ EXPORT_C TBool TRealX::IsFinite() const +/** +Determines whether the extended precision value has a finite value. + +@return True, if the extended precision value is finite, + false, if the value is 'not a number' or is infinite, +*/ + { + _asm mov eax, [ecx+8] // check exponent + _asm cmp eax, 0xFFFF0000 // check for NaN or infinity + _asm jnc short isfinite0 // branch if NaN or infinity + _asm mov eax, 1 // return 1 if finite + _asm ret + isfinite0: + _asm xor eax, eax // return 0 if NaN or infinity + _asm ret + } + + + + +__NAKED__ EXPORT_C const TRealX& TRealX::operator+=(const TRealX& /*aVal*/) +/** +Adds an extended precision value to this extended precision number. + +@param aVal The extended precision value to be added. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXAdd // do addition, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result in *this + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return this in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C const TRealX& TRealX::operator-=(const TRealX& /*aVal*/) +/** +Subtracts an extended precision value from this extended precision number. + +@param aVal The extended precision value to be subtracted. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXSubtract // do subtraction, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result in *this + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return this in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C const TRealX& TRealX::operator*=(const TRealX& /*aVal*/) +/** +Multiplies this extended precision number by an extended precision value. + +@param aVal The extended precision value to be subtracted. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXMultiply // do multiplication, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result in *this + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return this in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C const TRealX& TRealX::operator/=(const TRealX& /*aVal*/) +/** +Divides this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the divisor. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +@panic MATHX KErrDivideByZero if the divisor is zero. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXDivide // do division, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result in *this + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return this in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C const TRealX& TRealX::operator%=(const TRealX& /*aVal*/) +/** +Modulo-divides this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the divisor. + +@return A reference to this object. + +@panic MATHX KErrTotalLossOfPrecision panic if precision is lost. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXModulo // do modulo, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result in *this + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return this in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 + } + + + + +__NAKED__ EXPORT_C TInt TRealX::AddEq(const TRealX& /*aVal*/) +/** +Adds an extended precision value to this extended precision number. + +@param aVal The extended precision value to be added. + +@return KErrNone, if the operation is successful; + KErrOverflow,if the operation results in overflow; + KErrUnderflow, if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXAdd // do addition, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::SubEq(const TRealX& /*aVal*/) +/** +Subtracts an extended precision value from this extended precision number. + +@param aVal The extended precision value to be subtracted. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXSubtract // do subtraction, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::MultEq(const TRealX& /*aVal*/) +/** +Multiplies this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the multiplier. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXMultiply // do multiplication, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::DivEq(const TRealX& /*aVal*/) +/** +Divides this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the divisor. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow; + KErrDivideByZero, if the divisor is zero. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXDivide // do division, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::ModEq(const TRealX& /*aVal*/) +/** +Modulo-divides this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the divisor. + +@return KErrNone, if the operation is successful; + KErrTotalLossOfPrecision, if precision is lost; + KErrUnderflow, if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+20] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXModulo // do modulo, result in ecx,edx:ebx, error code in eax + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 4 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator+() const +/** +Returns this extended precision number unchanged. + +Note that this may also be referred to as a unary plus operator. + +@return The extended precision number. +*/ + { + _asm mov eax, [esp+4] // eax=address to write return value + _asm mov edx, [ecx] + _asm mov [eax], edx + _asm mov edx, [ecx+4] + _asm mov [eax+4], edx + _asm mov edx, [ecx+8] + _asm mov [eax+8], edx + _asm ret 4 // return address of return value in eax + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator-() const +/** +Negates this extended precision number. + +This may also be referred to as a unary minus operator. + +@return The negative of the extended precision number. +*/ + { + _asm mov eax, [esp+4] // eax=address to write return value + _asm mov edx, [ecx] + _asm mov [eax], edx + _asm mov edx, [ecx+4] + _asm mov [eax+4], edx + _asm mov edx, [ecx+8] + _asm xor dl, 1 // change sign bit + _asm mov [eax+8], edx + _asm ret 4 // return address of return value in eax + } + + + + +__NAKED__ EXPORT_C TRealX& TRealX::operator++() +/** +Increments this extended precision number by one, +and then returns a reference to it. + +This is also referred to as a prefix operator. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // pre-increment + // on entry ecx=this, return this in eax + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, 0x7FFF0000 // set ecx,edx:ebx to 1.0 + _asm mov edx, 0x80000000 + _asm xor ebx, ebx + _asm call TRealXAdd // add 1 to *this + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax // check error code + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // else return this in eax + _asm pop edi + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator++(TInt) +/** +Returns this extended precision number before incrementing it by one. + +This is also referred to as a postfix operator. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // post-increment + // on entry ecx=this, [esp+4]=address of return value, [esp+8]=dummy int + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov edi, [esp+20] // address of return value into edi + _asm mov eax, [ecx] // copy initial value of *this into [edi] + _asm mov [edi], eax + _asm mov eax, [ecx+4] + _asm mov [edi+4], eax + _asm mov eax, [ecx+8] + _asm mov [edi+8], eax + _asm mov ecx, 0x7FFF0000 // set ecx,edx:ebx to 1.0 + _asm mov edx, 0x80000000 + _asm xor ebx, ebx + _asm call TRealXAdd // add 1 to *this + _asm mov [esi], ebx // store result in *this + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax // check error code + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, [esp+20] // address of return value into eax + _asm pop edi + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TRealX& TRealX::operator--() +/** +Decrements this extended precision number by one, +and then returns a reference to it. + +This is also referred to as a prefix operator. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // pre-decrement + // on entry ecx=this, return this in eax + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, 0x7FFF0001 // set ecx,edx:ebx to -1.0 + _asm mov edx, 0x80000000 + _asm xor ebx, ebx + _asm call TRealXAdd // add -1 to *this + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax // check error code + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // else return this in eax + _asm pop edi + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator--(TInt) +/** +Returns this extended precision number before decrementing it by one. + +This is also referred to as a postfix operator. + +@return A reference to this object. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // post-decrement + // on entry ecx=this, [esp+4]=address of return value, [esp+8]=dummy int + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov edi, [esp+20] // address of return value into edi + _asm mov eax, [ecx] // copy initial value of *this into [edi] + _asm mov [edi], eax + _asm mov eax, [ecx+4] + _asm mov [edi+4], eax + _asm mov eax, [ecx+8] + _asm mov [edi+8], eax + _asm mov ecx, 0x7FFF0001 // set ecx,edx:ebx to -1.0 + _asm mov edx, 0x80000000 + _asm xor ebx, ebx + _asm call TRealXAdd // add -1 to *this + _asm mov [esi], ebx // store result in *this + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax // check error code + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, [esp+20] // address of return value into eax + _asm pop edi + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator+(const TRealX& /*aVal*/) const +/** +Adds an extended precision value to this extended precision number. + +@param aVal The extended precision value to be added. + +@return An extended precision object containing the result. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of return value, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXAdd // do addition, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of return value + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return address of return value in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator-(const TRealX& /*aVal*/) const +/** +Subtracts an extended precision value from this extended precision number. + +@param aVal The extended precision value to be subtracted. + +@return An extended precision object containing the result. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of return value, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXSubtract // do subtraction, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of return value + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return address of return value in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator*(const TRealX& /*aVal*/) const +/** +Multiplies this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the multiplier. + +@return An extended precision object containing the result. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of return value, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXMultiply // do multiplication, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of return value + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return address of return value in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator/(const TRealX& /*aVal*/) const +/** +Divides this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the divisor. + +@return An extended precision object containing the result. + +@panic MATHX KErrOverflow if the operation results in overflow. +@panic MATHX KErrUnderflow if the operation results in underflow. +@panic MATHX KErrDivideByZero if the divisor is zero. +*/ + { + // on entry ecx=this, [esp+4]=address of return value, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXDivide // do division, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of return value + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return address of return value in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TRealX TRealX::operator%(const TRealX& /*aVal*/) const +/** +Modulo-divides this extended precision number by an extended precision value. + +@param aVal The extended precision value to be used as the divisor. + +@return An extended precision object containing the result. + +@panic MATHX KErrTotalLossOfPrecision if precision is lost. +@panic MATHX KErrUnderflow if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of return value, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXModulo // do modulo, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of return value + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm test eax, eax + _ASM_jn(z,TRealXPanicEax) // panic if error + _asm mov eax, esi // return address of return value in eax + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Add(TRealX& /*aResult*/, const TRealX& /*aVal*/) const +/** +Adds an extended precision value to this extended precision number. + +@param aResult On return, a reference to an extended precision object + containing the result of the operation. +@param aVal The extended precision value to be added. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aResult, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXAdd // do addition, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of aResult + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Sub(TRealX& /*aResult*/, const TRealX& /*aVal*/) const +/** +Subtracts an extended precision value from this extended precision number. + +@param aResult On return, a reference to an extended precision object + containing the result of the operation. +@param aVal The extended precision value to be subtracted. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aResult, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXSubtract // do subtraction, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of aResult + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Mult(TRealX& /*aResult*/, const TRealX& /*aVal*/) const +/** +Multiplies this extended precision number by an extended precision value. + +@param aResult On return, a reference to an extended precision object + containing the result of the operation. +@param aVal The extended precision value to be used as the multiplier. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aResult, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXMultiply // do multiplication, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of aResult + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Div(TRealX& /*aResult*/, const TRealX& /*aVal*/) const +/** +Divides this extended precision number by an extended precision value. + +@param aResult On return, a reference to an extended precision object + containing the result of the operation. +@param aVal The extended precision value to be used as the divisor. + +@return KErrNone, if the operation is successful; + KErrOverflow, if the operation results in overflow; + KErrUnderflow, if the operation results in underflow; + KErrDivideByZero, if the divisor is zero. +*/ + { + // on entry ecx=this, [esp+4]=address of aResult, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXDivide // do division, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of aResult + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 // return with error code in eax + } + + + + +__NAKED__ EXPORT_C TInt TRealX::Mod(TRealX& /*aResult*/, const TRealX& /*aVal*/) const +/** +Modulo-divides this extended precision number by an extended precision value. + +@param aResult On return, a reference to an extended precision object + containing the result of the operation. + +@param aVal The extended precision value to be used as the divisor. + +@return KErrNone, if the operation is successful; + KErrTotalLossOfPrecision, if precision is lost; + KErrUnderflow, if the operation results in underflow. +*/ + { + // on entry ecx=this, [esp+4]=address of aResult, [esp+8]=address of aVal + _asm push ebx // save registers + _asm push ebp + _asm push esi + _asm push edi + _asm mov esi, ecx // this into esi + _asm mov ecx, [esp+24] // address of aVal into ecx + _asm mov ebx, [ecx] // aVal into ecx,edx:ebx + _asm mov edx, [ecx+4] + _asm mov ecx, [ecx+8] + _asm call TRealXModulo // do modulo, result in ecx,edx:ebx, error code in eax + _asm mov esi, [esp+20] // esi=address of aResult + _asm mov [esi], ebx // store result + _asm mov [esi+4], edx + _asm mov [esi+8], ecx + _asm pop edi // restore registers + _asm pop esi + _asm pop ebp + _asm pop ebx + _asm ret 8 // return with error code in eax + } + +// Compare TRealX in ecx,edx:ebx (op1) to TRealX at [esi] (op2) +// Return 1 if op1op2 +// Return 8 if unordered +// Return value in eax +__NAKED__ LOCAL_C void TRealXCompare(void) + { + _asm cmp ecx, 0xFFFF0000 // check if op1=NaN or infinity + _asm jc short fpcmp1 // branch if not + _asm cmp edx, 0x80000000 // check for infinity + _asm jnz short fpcmpunord // branch if NaN + _asm test ebx, ebx + _asm jz short fpcmp1 // if infinity, process normally + fpcmpunord: // come here if unordered + _asm mov eax, 8 // return 8 + _asm ret + fpcmp1: // op1 is not a NaN + _asm mov eax, [esi+8] // get op2 into eax,edi:ebp + _asm mov edi, [esi+4] + _asm mov ebp, [esi] + _asm cmp eax, 0xFFFF0000 // check for NaN or infinity + _asm jc short fpcmp2 // branch if neither + _asm cmp edi, 0x80000000 // check for infinity + _asm jnz short fpcmpunord // branch if NaN + _asm test ebp, ebp + _asm jnz short fpcmpunord + fpcmp2: // neither operand is a NaN + _asm cmp ecx, 0x10000 // check if op1=0 + _asm jc short fpcmpop1z // branch if it is + _asm cmp eax, 0x10000 // check if op2=0 + _asm jc short fpcmp4 // branch if it is + _asm xor al, cl // check if signs the same + _asm test al, 1 + _asm jnz short fpcmp4 // branch if different + _asm push ecx + _asm shr ecx, 16 // op1 exponent into cx + _asm shr eax, 16 // op2 exponent into ax + _asm cmp ecx, eax // compare exponents + _asm pop ecx + _asm ja short fpcmp4 // if op1 exp > op2 exp op1>op2 if +ve + _asm jb short fpcmp5 // if op1 exp < op2 exp op1ABS(op2) or if signs different + // or if op2 zero, op1 nonzero + _asm mov eax, 4 // return 4 if +ve + _asm test cl, 1 // check sign + _asm jz short fpcmp4a // skip if + + _asm mov al, 1 // return 1 if -ve + fpcmp4a: + _asm ret + fpcmp5: // come here if ABS(op1)