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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

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

    15 // 

    16 //

    17 

    18 #include "u32std.h"

    19 #include <e32math.h>

    20 

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

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

    23 									// having been initialised

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

    25 

    26 

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

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

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

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

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

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

    33 #else

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

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

    36 #endif

    37 

    38 //

    39 // 64-bit precision floating point routines

    40 // Register storage format:

    41 // edx:ebx=64 bit normalised mantissa

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

    43 // ecx bit 0 = sign

    44 // ecx bit 8 = rounded-down flag

    45 // ecx bit 9 = rounded-up flag

    46 //

    47 // Memory storage format:

    48 // 3 doublewords per number

    49 // Low 32 bits of mantissa at [addr]

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

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

    52 //

    53 

    54 LOCAL_C void TRealXPanic(TInt aErr)

    55 	{

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

    57 	}

    58 

    59 __NAKED__ LOCAL_C void TRealXPanicEax(void)

    60 	{

    61 	_asm push eax

    62 	_asm call TRealXPanic

    63 	}

    64 

    65 LOCAL_C __NAKED__ void TRealXRealIndefinite(void)

    66 	{

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

    68 	_asm mov ecx, 0xFFFF0001	// exponent=FFFF, sign negative

    69 	_asm mov edx, 0xC0000000	// mantissa=C0000000 00000000

    70 	_asm xor ebx, ebx

    71 	_asm mov eax, -6			// return KErrArgument

    72 	_asm ret

    73 	}

    74 

    75 LOCAL_C __NAKED__ void TRealXBinOpNaN(void)

    76 	{

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

    78 	// destination operand in ecx,edx:eax

    79 	// source operand at [esi]

    80 

    81 	_asm mov eax, [esi+8]		// source operand into eax,edi:ebp

    82 	_asm mov edi, [esi+4]

    83 	_asm mov ebp, [esi]

    84 	_asm cmp ecx, 0xFFFF0000	// check if dest is a NaN

    85 	_asm jb short TRealXBinOpNaN1	// if not, swap them

    86 	_asm cmp edx, 0x80000000

    87 	_asm jne short TRealXBinOpNaN2

    88 	_asm test ebx, ebx

    89 	_asm jne short TRealXBinOpNaN2

    90 	TRealXBinOpNaN1:			// swap the operands

    91 	_asm xchg ecx, eax

    92 	_asm xchg edx, edi

    93 	_asm xchg ebx, ebp

    94 	TRealXBinOpNaN2:

    95 	_asm cmp eax, 0xFFFF0000	// check if both operands are NaNs

    96 	_asm jb short TRealXBinOpNaN4	// if not, ignore non-NaN operand

    97 	_asm cmp edi, 0x80000000

    98 	_asm jne short TRealXBinOpNaN3

    99 	_asm test ebp, ebp

   100 	_asm je short TRealXBinOpNaN4

   101 	TRealXBinOpNaN3:			// if both operands are NaN's, compare significands

   102 	_asm cmp edx, edi

   103 	_asm ja short TRealXBinOpNaN4

   104 	_asm jb short TRealXBinOpNaN5

   105 	_asm cmp ebx, ebp

   106 	_asm jae short TRealXBinOpNaN4

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

   108 	_asm mov ecx, eax

   109 	_asm mov edx, edi

   110 	_asm mov ebx, ebp

   111 	TRealXBinOpNaN4:			// NaN with larger significand is in ecx,edx:ebx

   112 	_asm or edx, 0x40000000		// convert an SNaN to a QNaN

   113 	_asm mov eax, -6			// return KErrArgument

   114 	_asm ret

   115 	}

   116 

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

   118 // Result in ecx,edx:ebx

   119 // Error code in eax

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

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

   122 __NAKED__ LOCAL_C void TRealXAdd()

   123 	{

   124 	_asm xor ch, ch				// clear rounding flags

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

   126 	_asm jnc addfpsd			// branch if it is

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

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

   129 	_asm jnc addfpss			// branch if it is

   130 	_asm cmp eax, 0x10000		// check if source=0

   131 	_asm jc addfp0s				// branch if it is

   132 	_asm cmp ecx, 0x10000		// check if dest=0

   133 	_asm jc addfp0d				// branch if it is

   134 	_asm and cl, 1				// clear bits 1-7 of ecx

   135 	_asm and al, 1				// clear bits 1-7 of eax

   136 	_asm mov ch, cl

   137 	_asm xor ch, al				// xor of signs into ch bit 0

   138 	_asm add ch, ch

   139 	_asm or cl, ch				// and into cl bit 1

   140 	_asm or al, ch				// and al bit 1

   141 	_asm xor ch, ch				// clear rounding flags

   142 	_asm mov ebp, [esi]			// fetch source mantissa 0-31

   143 	_asm mov edi, [esi+4]		// fetch source mantissa 32-63

   144 	_asm ror ecx, 16			// dest exponent into cx

   145 	_asm ror eax, 16			// source exponent into ax

   146 	_asm push ecx				// push dest exponent/sign

   147 	_asm sub cx, ax				// cx = dest exponent - source exponent

   148 	_asm je short addfp3b		// if equal, no shifting required

   149 	_asm ja short addfp1		// branch if dest exponent >= source exponent

   150 	_asm xchg ebx, ebp			// make sure edi:ebp contains the mantissa to be shifted

   151 	_asm xchg edx, edi			//

   152 	_asm xchg eax, [esp]		// and larger exponent and corresponding sign is on the stack

   153 	_asm neg cx					// make cx positive = number of right shifts needed

   154 	addfp1:

   155 	_asm cmp cx, 64				// if more than 64 shifts needed

   156 	_asm ja addfp2				// branch to output larger number

   157 	_asm jb addfp3				// branch if <64 shifts

   158 	_asm mov eax, edi			// exactly 64 shifts needed - rounding word=mant high

   159 	_asm test ebp, ebp			// check bits lost

   160 	_asm jz short addfp3a

   161 	_asm or ch, 1				// if not all zero, set rounded-down flag

   162 	addfp3a:

   163 	_asm xor edi, edi			// clear edx:ebx

   164 	_asm xor ebp, ebp

   165 	_asm jmp short addfp5		// finished shifting

   166 	addfp3b:					// exponents equal

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

   168 	_asm jmp short addfp5

   169 	addfp3:

   170 	_asm cmp cl, 32				// 32 or more shifts needed ?

   171 	_asm jb short addfp4		// skip if <32

   172 	_asm mov eax, ebp			// rounding word=mant low

   173 	_asm mov ebp, edi			// mant low=mant high

   174 	_asm xor edi, edi			// mant high=0

   175 	_asm sub cl, 32				// reduce count by 32

   176 	_asm jz short addfp5		// if now zero, finished shifting

   177 	_asm shrd edi, eax, cl		// shift ebp:eax:edi right by cl bits

   178 	_asm shrd eax, ebp, cl		//

   179 	_asm shr ebp, cl			//

   180 	_asm test edi, edi			// check bits lost in shift

   181 	_asm jz short addfp5		// if all zero, finished

   182 	_asm or ch, 1				// else set rounded-down flag

   183 	_asm xor edi, edi			// clear edx again

   184 	_asm jmp short addfp5		// finished shifting

   185 	addfp4:						// <32 shifts needed now

   186 	_asm xor eax, eax			// clear rounding word initially

   187 	_asm shrd eax, ebp, cl		// shift edi:ebp:eax right by cl bits

   188 	_asm shrd ebp, edi, cl		//

   189 	_asm shr edi, cl			//

   190 

   191 	addfp5:

   192 	_asm mov [esp+3], ch		// rounding flag into ch image on stack

   193 	_asm pop ecx				// recover sign and exponent into ecx, with rounding flag

   194 	_asm ror ecx, 16			// into normal position

   195 	_asm test cl, 2				// addition or subtraction needed ?

   196 	_asm jnz short subfp1		// branch if subtraction

   197 	_asm add ebx,ebp			// addition required - add mantissas

   198 	_asm adc edx,edi			//

   199 	_asm jnc short roundfp		// branch if no carry

   200 	_asm rcr edx,1				// shift carry right into mantissa

   201 	_asm rcr ebx,1				//

   202 	_asm rcr eax,1				// and into rounding word

   203 	_asm jnc short addfp5a

   204 	_asm or ch, 1				// if 1 shifted out, set rounded-down flag

   205 	addfp5a:

   206 	_asm add ecx, 0x10000		// and increment exponent

   207 

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

   209 	roundfp:

   210 	_asm cmp eax, 0x80000000

   211 	_asm jc roundfp0			// if rounding word<80000000, round down

   212 	_asm ja roundfp1			// if >80000000, round up

   213 	_asm test ch, 1

   214 	_asm jnz short roundfp1		// if rounded-down flag set, round up

   215 	_asm test ch, 2

   216 	_asm jnz short roundfp0		// if rounded-up flag set, round down

   217 	_asm test bl, 1				// else test mantissa lsb

   218 	_asm jz short roundfp0		// round down if 0, up if 1 (round to even)

   219 	roundfp1:					// Come here to round up

   220 	_asm add ebx, 1				// increment mantissa

   221 	_asm adc edx,0				//

   222 	_asm jnc roundfp1a			// if no carry OK

   223 	_asm rcr edx,1				// else shift carry into mantissa (edx:ebx=0 here)

   224 	_asm add ecx, 0x10000		// and increment exponent

   225 	roundfp1a:

   226 	_asm cmp ecx, 0xFFFF0000	// check for overflow

   227 	_asm jae short addfpovfw	// jump if overflow

   228 	_asm mov ch, 2				// else set rounded-up flag

   229 	_asm xor eax, eax			// return KErrNone

   230 	_asm ret

   231 

   232 	roundfp0:					// Come here to round down

   233 	_asm cmp ecx, 0xFFFF0000	// check for overflow

   234 	_asm jae short addfpovfw	// jump if overflow

   235 	_asm test eax, eax			// else check if rounding word zero

   236 	_asm jz short roundfp0a		// if so, leave rounding flags as they are

   237 	_asm mov ch, 1				// else set rounded-down flag

   238 	roundfp0a:

   239 	_asm xor eax, eax			// return KErrNone

   240 	_asm ret					// exit

   241 

   242 	addfpovfw:					// Come here if overflow occurs

   243 	_asm xor ch, ch				// clear rounding flags, exponent=FFFF

   244 	_asm xor ebx, ebx

   245 	_asm mov edx, 0x80000000	// mantissa=80000000 00000000 for infinity

   246 	_asm mov eax, -9			// return KErrOverflow

   247 	_asm ret

   248 

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

   250 	addfp2:

   251 	_asm pop ecx				// recover exponent and sign

   252 	_asm ror ecx, 16			// into normal position

   253 	_asm or ch, 1				// set rounded-down flag

   254 	_asm test cl, 2				// check if signs the same

   255 	_asm jz addfp2a

   256 	_asm xor ch, 3				// if not, set rounded-up flag

   257 	addfp2a:

   258 	_asm xor eax, eax			// return KErrNone

   259 	_asm ret

   260 

   261 	// signs differ, so must subtract mantissas

   262 	subfp1:

   263 	_asm add ch, ch				// if rounded-down flag set, change it to rounded-up

   264 	_asm neg eax				// subtract rounding word from 0

   265 	_asm sbb ebx, ebp			// and subtract mantissas with borrow

   266 	_asm sbb edx, edi			//

   267 	_asm jnc short subfp2		// if no borrow, sign is correct

   268 	_asm xor cl, 1				// else change sign of result

   269 	_asm shr ch, 1				// change rounding back to rounded-down

   270 	_asm not eax				// negate rounding word

   271 	_asm not ebx				// and mantissa

   272 	_asm not edx				//

   273 	_asm add eax,1				// two's complement negation

   274 	_asm adc ebx,0				//

   275 	_asm adc edx,0				//

   276 	subfp2:

   277 	_asm jnz short subfp3		// branch if edx non-zero at this point

   278 	_asm mov edx, ebx			// else shift ebx into edx

   279 	_asm or edx, edx			//

   280 	_asm jz short subfp4		// if still zero, branch

   281 	_asm mov ebx, eax			// else shift rounding word into ebx

   282 	_asm xor eax, eax			// and zero rounding word

   283 	_asm sub ecx, 0x200000		// decrease exponent by 32 due to shift

   284 	_asm jnc short subfp3		// if no borrow, carry on

   285 	_asm jmp short subfpundflw	// if borrow here, underflow

   286 	subfp4:

   287 	_asm mov edx, eax			// move rounding word into edx

   288 	_asm or edx, edx			// is edx still zero ?

   289 	_asm jz short subfp0		// if so, result is precisely zero

   290 	_asm xor ebx, ebx			// else zero ebx and rounding word

   291 	_asm xor eax, eax			//

   292 	_asm sub ecx, 0x400000		// and decrease exponent by 64 due to shift

   293 	_asm jc short subfpundflw	// if borrow, underflow

   294 	subfp3:

   295 	_asm mov edi, ecx			// preserve sign and exponent

   296 	_asm bsr ecx, edx			// position of most significant 1 into ecx

   297 	_asm neg ecx				//

   298 	_asm add ecx, 31			// cl = 31-position of MS 1 = number of shifts to normalise

   299 	_asm shld edx, ebx, cl		// shift edx:ebx:eax left by cl bits

   300 	_asm shld ebx, eax, cl		//

   301 	_asm shl eax, cl			//

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

   303 	_asm shl ebp, 16			// shift left by 16 to align with exponent

   304 	_asm mov ecx, edi			// exponent, sign, rounding flags back into ecx

   305 	_asm sub ecx, ebp			// subtract shift count from exponent

   306 	_asm jc short subfpundflw	// if borrow, underflow

   307 	_asm cmp ecx, 0x10000		// check if exponent 0

   308 	_asm jnc roundfp			// if not, jump to round result, else underflow

   309 

   310 	// come here if underflow

   311 	subfpundflw:

   312 	_asm and ecx, 1				// set exponent to zero, leave sign

   313 	_asm xor edx, edx

   314 	_asm xor ebx, ebx

   315 	_asm mov eax, -10			// return KErrUnderflow

   316 	_asm ret

   317 

   318 	// come here to return zero result

   319 	subfp0:

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

   321 	_asm xor edx, edx

   322 	_asm xor ebx, ebx

   323 	addfp0snzd:

   324 	_asm xor eax, eax			// return KErrNone

   325 	_asm ret

   326 

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

   328 	addfp0s:

   329 	_asm cmp ecx, 0x10000		// check if dest=0

   330 	_asm jnc addfp0snzd			// if not, return dest unaltered

   331 	_asm and ecx, eax			// else both zero, result negative iff both zeros negative

   332 	_asm and ecx, 1

   333 	_asm xor eax, eax			// return KErrNone

   334 	_asm ret

   335 

   336 	// come here if dest=0, source nonzero

   337 	addfp0d:

   338 	_asm mov ebx, [esi]			// return source unaltered

   339 	_asm mov edx, [esi+4]

   340 	_asm mov ecx, [esi+8]

   341 	_asm xor eax, eax			// return KErrNone

   342 	_asm ret

   343 

   344 	// come here if dest=NaN or infinity

   345 	addfpsd:

   346 	_asm cmp edx, 0x80000000	// check for infinity

   347 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   348 	_asm test ebx, ebx

   349 	_ASM_jn(e,TRealXBinOpNaN)

   350 	_asm mov eax, [esi+8]		// eax=second operand exponent

   351 	_asm cmp eax, 0xFFFF0000	// check second operand for NaN or infinity

   352 	_asm jae short addfpsd1		// branch if NaN or infinity

   353 	addfpsd2:

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

   355 	_asm ret

   356 	addfpsd1:

   357 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

   358 	_asm mov edi, [esi+4]

   359 	_asm cmp edi, 0x80000000	// check for infinity

   360 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   361 	_asm test ebp, ebp

   362 	_ASM_jn(e,TRealXBinOpNaN)

   363 	_asm xor al, cl				// both operands are infinity - check signs

   364 	_asm test al, 1

   365 	_asm jz short addfpsd2		// if both the same, return KErrOverflow

   366 	_asm jmp TRealXRealIndefinite	// else return 'real indefinite'

   367 

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

   369 	addfpss:

   370 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

   371 	_asm mov edi, [esi+4]

   372 	_asm cmp edi, 0x80000000	// check for infinity

   373 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   374 	_asm test ebp, ebp

   375 	_ASM_jn(e,TRealXBinOpNaN)

   376 	_asm mov ecx, eax			// if source=infinity, return source unaltered

   377 	_asm mov edx, edi

   378 	_asm mov ebx, ebp

   379 	_asm mov eax, -9			// return KErrOverflow

   380 	_asm ret

   381 	}

   382 

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

   384 // Result in ecx,edx:ebx

   385 // Error code in eax

   386 __NAKED__ LOCAL_C void TRealXSubtract()

   387 	{

   388 	_asm xor cl, 1              // negate subtrahend

   389 	_asm jmp TRealXAdd

   390 	}

   391 

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

   393 // Result in ecx,edx:ebx

   394 // Error code in eax

   395 __NAKED__ LOCAL_C void TRealXMultiply()

   396 	{

   397 	_asm xor ch, ch				// clear rounding flags

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

   399 	_asm xor cl, al				// xor signs

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

   401 	_asm jnc mulfpsd			// branch if it is

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

   403 	_asm jnc mulfpss			// branch if it is

   404 	_asm cmp eax, 0x10000		// check if source=0

   405 	_asm jc mulfp0				// branch if it is

   406 	_asm cmp ecx, 0x10000		// check if dest=0

   407 	_asm jc mulfp0				// branch if it is

   408 	_asm push ecx				// save result sign

   409 	_asm shr ecx, 16			// dest exponent into cx

   410 	_asm shr eax, 16			// source exponent into ax

   411 	_asm add eax, ecx			// add exponents

   412 	_asm sub eax, 0x7FFE		// eax now contains result exponent

   413 	_asm push eax				// save it

   414 	_asm mov edi, edx			// save dest mantissa high

   415 	_asm mov eax, ebx			// dest mantissa low -> eax

   416 	_asm mul dword ptr [esi]	// dest mantissa low * source mantissa low -> edx:eax

   417 	_asm xchg ebx, eax			// result dword 0 -> ebx, dest mant low -> eax

   418 	_asm mov ebp, edx			// result dword 1 -> ebp

   419 	_asm mul dword ptr [esi+4]	// dest mant low * src mant high -> edx:eax

   420 	_asm add ebp, eax			// add in partial product to dwords 1 and 2

   421 	_asm adc edx, 0				//

   422 	_asm mov ecx, edx			// result dword 2 -> ecx

   423 	_asm mov eax, edi			// dest mant high -> eax

   424 	_asm mul dword ptr [esi+4]	// dest mant high * src mant high -> edx:eax

   425 	_asm add ecx, eax			// add in partial product to dwords 2, 3

   426 	_asm adc edx, 0				//

   427 	_asm mov eax, edi			// dest mant high -> eax

   428 	_asm mov edi, edx			// result dword 3 -> edi

   429 	_asm mul dword ptr [esi]	// dest mant high * src mant low -> edx:eax

   430 	_asm add ebp, eax			// add in partial product to dwords 1, 2

   431 	_asm adc ecx, edx			//

   432 	_asm adc edi, 0				// 128-bit mantissa product is now in edi:ecx:ebp:ebx

   433 	_asm mov edx, edi			// top 64 bits into edx:ebx

   434 	_asm mov edi, ebx

   435 	_asm mov ebx, ecx			// bottom 64 bits now in ebp:edi

   436 	_asm pop ecx				// recover exponent

   437 	_asm js short mulfp1		// skip if mantissa normalised

   438 	_asm add edi, edi			// else shift left (only one shift will be needed)

   439 	_asm adc ebp, ebp

   440 	_asm adc ebx, ebx

   441 	_asm adc edx, edx

   442 	_asm dec ecx				// and decrement exponent

   443 	mulfp1:

   444 	_asm cmp ebp, 0x80000000	// compare bottom 64 bits with 80000000 00000000 for rounding

   445 	_asm ja short mulfp2		// branch to round up

   446 	_asm jb short mulfp3		// branch to round down

   447 	_asm test edi, edi

   448 	_asm jnz short mulfp2		// branch to round up

   449 	_asm test bl, 1				// if exactly half-way, test LSB of result mantissa

   450 	_asm jz short mulfp4		// if LSB=0, round down (round to even)

   451 	mulfp2:

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

   453 	_asm adc edx, 0

   454 	_asm jnc short mulfp2a

   455 	_asm rcr edx, 1

   456 	_asm inc ecx

   457 	mulfp2a:

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

   459 	_asm jmp short mulfp5

   460 	mulfp3:						// round down

   461 	_asm xor al, al				// clear rounding flags

   462 	_asm or ebp, edi			// check for exact result

   463 	_asm jz short mulfp5		// skip if exact

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

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

   466 	mulfp5:						// final mantissa now in edx:ebx, exponent in ecx

   467 	_asm cmp ecx, 0xFFFF		// check for overflow

   468 	_asm jge short mulfp6		// branch if overflow

   469 	_asm cmp ecx, 0				// check for underflow

   470 	_asm jle short mulfp7		// branch if underflow

   471 	_asm shl ecx, 16			// else exponent up to top end of ecx

   472 	_asm mov ch, al				// rounding flags into ch

   473 	_asm pop eax				// recover result sign

   474 	_asm mov cl, al				// into cl

   475 	_asm xor eax, eax			// return KErrNone

   476 	_asm ret

   477 

   478 	// come here if overflow

   479 	mulfp6:

   480 	_asm pop eax				// recover result sign

   481 	_asm mov ecx, 0xFFFF0000	// exponent=FFFF

   482 	_asm mov cl, al				// sign into cl

   483 	_asm mov edx, 0x80000000	// set mantissa to 80000000 00000000 for infinity

   484 	_asm xor ebx, ebx

   485 	_asm mov eax, -9			// return KErrOverflow

   486 	_asm ret

   487 

   488 	// come here if underflow

   489 	mulfp7:

   490 	_asm pop eax				// recover result sign

   491 	_asm xor ecx, ecx			// exponent=0

   492 	_asm mov cl, al				// sign into cl

   493 	_asm xor edx, edx

   494 	_asm xor ebx, ebx

   495 	_asm mov eax, -10			// return KErrUnderflow

   496 	_asm ret

   497 

   498 	// come here if either operand zero

   499 	mulfp0:

   500 	_asm and ecx, 1				// set exponent=0, keep sign

   501 	_asm xor edx, edx

   502 	_asm xor ebx, ebx

   503 	_asm xor eax, eax			// return KErrNone

   504 	_asm ret

   505 

   506 	// come here if destination operand NaN or infinity

   507 	mulfpsd:

   508 	_asm cmp edx, 0x80000000	// check for infinity

   509 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   510 	_asm test ebx, ebx

   511 	_ASM_jn(e,TRealXBinOpNaN)

   512 	_asm cmp eax, 0xFFFF0000	// check second operand for NaN or infinity

   513 	_asm jae short mulfpsd1		// branch if NaN or infinity

   514 	_asm cmp eax, 0x10000		// check if second operand zero

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

   516 	_asm mov eax, -9			// else return dest (infinity) with xor sign and KErrOverflow

   517 	_asm ret

   518 	mulfpsd1:

   519 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

   520 	_asm mov edi, [esi+4]

   521 	_asm cmp edi, 0x80000000	// check for infinity

   522 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   523 	_asm test ebp, ebp

   524 	_ASM_jn(e,TRealXBinOpNaN)

   525 	_asm mov eax, -9			// both operands infinity - return infinity with xor sign

   526 	_asm ret					// and KErrOverflow

   527 

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

   529 	mulfpss:

   530 	_asm mov ebp, [esi]			// source mantissa into edi:ebp

   531 	_asm mov edi, [esi+4]

   532 	_asm cmp edi, 0x80000000	// check for infinity

   533 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   534 	_asm test ebp, ebp

   535 	_ASM_jn(e,TRealXBinOpNaN)

   536 	_asm cmp ecx, 0x10000		// source=infinity, check if dest=0

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

   538 	_asm or ecx, 0xFFFF0000		// set exp=FFFF, leave xor sign in cl

   539 	_asm mov edx, edi			// set mantissa for infinity

   540 	_asm mov ebx, ebp

   541 	_asm mov eax, -9			// return KErrOverflow

   542 	_asm ret

   543 	}

   544 

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

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

   547 // Assume the quotient fits in 32 bits

   548 // Return 32 bit quotient in EDI

   549 // Return 64 bit remainder in EBP:ESI

   550 __NAKED__ LOCAL_C void LongDivide(void)

   551 	{

   552 	_asm push edx				// save dividend

   553 	_asm push eax				//

   554 	_asm cmp edx, ecx			// check if truncation of divisor will overflow DIV instruction

   555 	_asm jb short longdiv1		// skip if not

   556 	_asm xor eax, eax			// else return quotient of 0xFFFFFFFF

   557 	_asm dec eax				//

   558 	_asm jmp short longdiv2		//

   559 	longdiv1:

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

   561 	longdiv2:

   562 	_asm mov edi, eax			// save approx quotient

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

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

   565 	_asm mov ebp, edx			//

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

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

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

   569 	_asm adc edx, 0				//

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

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

   572 	_asm sbb ebp, eax			//

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

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

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

   576 	longdiv3:

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

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

   579 	_asm adc ebp, ecx			//

   580 	_asm adc eax, 0				//

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

   582 	longdiv4:

   583 	_asm add esp, 8				// remove dividend from stack

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

   585 	}

   586 

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

   588 // Result in ecx,edx:ebx

   589 // Error code in eax

   590 __NAKED__ LOCAL_C void TRealXDivide(void)

   591 	{

   592 	_asm xor ch, ch				// clear rounding flags

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

   594 	_asm xor cl, al				// xor signs

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

   596 	_asm jnc divfpss			// branch if it is

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

   598 	_asm jnc divfpsd			// branch if it is

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

   600 	_asm jc divfpdv0			// branch if it is

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

   602 	_asm jc divfpdd0			// branch if it is

   603 	_asm push esi				// save pointer to dividend

   604 	_asm push ecx				// save result sign

   605 	_asm shr ecx, 16			// divisor exponent into cx

   606 	_asm shr eax, 16			// dividend exponent into ax

   607 	_asm sub eax, ecx			// subtract exponents

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

   609 	_asm push eax				// save it

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

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

   612 	_asm mov eax, [esi]

   613 	_asm xor edi, edi			// clear edi initially

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

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

   616 	_asm ja short divfp2		//

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

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

   619 	divfp2:

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

   621 	_asm sbb edx, ecx			//

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

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

   624 	divfp1:

   625 	_asm push edi				// save top bit of result

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

   627 	_asm push edi				// save next 32 bits of result

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

   629 	_asm mov eax, esi			//

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

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

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

   633 	_asm xor eax, eax			//

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

   635 	_asm adc ebp, ebp			//

   636 	_asm adc eax, eax			//

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

   638 	_asm sbb ebp, ecx			//

   639 	_asm sbb eax, 0				//

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

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

   642 	_asm adc ebp, ecx			//

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

   644 	divfp3:

   645 	_asm cmc					// final bit = 1-C

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

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

   648 	_asm pop edx

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

   650 	_asm jmp short divfp5		// branch to round

   651 

   652 	divfp4:						// integer bit was set

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

   654 	_asm pop edx				//

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

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

   657 	_asm rcr edx,1				//

   658 	_asm rcr ebx,1				//

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

   660 

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

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

   663 	// and the remainder is in EBP:ESI

   664 	divfp5:

   665 	_asm pop ecx				// recover result exponent

   666 	_asm add eax, eax			// test rounding bit

   667 	_asm jnc short divfp6		// branch to round down

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

   669 	_asm jnz short divfp7		// if not, round up

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

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

   672 	divfp7:

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

   674 	_asm adc edx, 0

   675 	_asm jnc short divfp7a

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

   677 	_asm inc ecx				// and increment exponent

   678 	divfp7a:

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

   680 	_asm jmp short divfp9

   681 	divfp6:

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

   683 	_asm or ebp, esi			// test if result exact

   684 	_asm jz short divfp9		// skip if exact

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

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

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

   688 	_asm cmp ecx, 0xFFFF		// check for overflow

   689 	_asm jge short divfp10		// branch if overflow

   690 	_asm cmp ecx, 0				// check for underflow

   691 	_asm jle short divfp11		// branch if underflow

   692 	_asm shl ecx, 16			// else exponent up to top end of ecx

   693 	_asm mov ch, al				// rounding flags into ch

   694 	_asm pop eax				// recover result sign

   695 	_asm mov cl, al				// into cl

   696 	_asm pop esi				// recover dividend pointer

   697 	_asm xor eax, eax			// return KErrNone

   698 	_asm ret

   699 

   700 	// come here if overflow

   701 	divfp10:

   702 	_asm pop eax				// recover result sign

   703 	_asm mov ecx, 0xFFFF0000	// exponent=FFFF

   704 	_asm mov cl, al				// sign into cl

   705 	_asm mov edx, 0x80000000	// set mantissa to 80000000 00000000 for infinity

   706 	_asm xor ebx, ebx

   707 	_asm mov eax, -9			// return KErrOverflow

   708 	_asm pop esi				// recover dividend pointer

   709 	_asm ret

   710 

   711 	// come here if underflow

   712 	divfp11:

   713 	_asm pop eax				// recover result sign

   714 	_asm xor ecx, ecx			// exponent=0

   715 	_asm mov cl, al				// sign into cl

   716 	_asm xor edx, edx

   717 	_asm xor ebx, ebx

   718 	_asm mov eax, -10			// return KErrUnderflow

   719 	_asm pop esi				// recover dividend pointer

   720 	_asm ret

   721 

   722 

   723 	// come here if divisor=0, dividend finite

   724 	divfpdv0:

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

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

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

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

   729 	_asm xor ebx, ebx

   730 	_asm mov eax, -41			// return KErrDivideByZero

   731 	_asm ret

   732 

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

   734 	divfpdd0:

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

   736 	_asm xor eax, eax			// return KErrNone

   737 	_asm ret

   738 

   739 	// come here if dividend is a NaN or infinity

   740 	divfpss:

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

   742 	_asm mov edi, [esi+4]

   743 	_asm cmp edi, 0x80000000	// check for infinity

   744 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   745 	_asm test ebp, ebp

   746 	_ASM_jn(e,TRealXBinOpNaN)

   747 	_asm cmp ecx, 0xFFFF0000	// check divisor for NaN or infinity

   748 	_asm jae short divfpss1		// branch if NaN or infinity

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

   750 	_asm mov edx, 0x80000000

   751 	_asm xor ebx, ebx

   752 	_asm mov eax, -9			// return KErrOverflow

   753 	_asm ret

   754 	divfpss1:

   755 	_asm cmp edx, 0x80000000	// check for infinity

   756 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   757 	_asm test ebx, ebx

   758 	_ASM_jn(e,TRealXBinOpNaN)

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

   760 

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

   762 	divfpsd:

   763 	_asm cmp edx, 0x80000000	// check for infinity

   764 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   765 	_asm test ebx, ebx

   766 	_ASM_jn(e,TRealXBinOpNaN)

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

   768 	_asm xor edx, edx

   769 	_asm xor ebx, ebx

   770 	_asm xor eax, eax			// return KErrNone

   771 	_asm ret

   772 	}

   773 

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

   775 // Result in ecx,edx:ebx

   776 // Error code in eax

   777 __NAKED__ LOCAL_C void TRealXModulo(void)

   778 	{

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

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

   781 	_asm xor ch, ch				// clear rounding flags

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

   783 	_asm jnc modfpss			// branch if it is

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

   785 	_asm jnc modfpsd			// branch if it is

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

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

   788 	_asm shr eax, 16			// ax=dividend exponent

   789 	_asm ror ecx, 16			// cx=divisor exponent

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

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

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

   793 	_asm jnc modfplp			// if so, underflow

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

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

   796 	_asm mov edi, [esi+4]		//

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

   798 	modfp1:

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

   800 	_asm adc edi, edi

   801 	_asm adc ah, ah

   802 	modfp2:

   803 	_asm sub ebp, ebx			// subtract divisor from dividend

   804 	_asm sbb edi, edx

   805 	_asm sbb ah, 0

   806 	_asm jnc short modfp3		// skip if no borrow

   807 	_asm add ebp, ebx			// else add back

   808 	_asm adc edi, edx

   809 	_asm adc ah, 0

   810 	modfp3:

   811 	_asm dec al					// any more bits to do?

   812 	_asm jns short modfp1		// loop if there are

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

   814 	_asm mov ebx, ebp

   815 	_asm or edi, ebx			// check for zero

   816 	_asm jz modfp0				// jump if result zero

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

   818 	_asm jnz short modfp4

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

   820 	_asm xor ebx, ebx

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

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

   823 	modfp4:

   824 	_asm mov edi, ecx			// preserve sign and exponent

   825 	_asm bsr ecx, edx			// position of most significant 1 into ecx

   826 	_asm neg ecx				//

   827 	_asm add ecx, 31			// cl = 31-position of MS 1 = number of shifts to normalise

   828 	_asm shld edx, ebx, cl		// shift edx:ebx left by cl bits

   829 	_asm shl ebx, cl			//

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

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

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

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

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

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

   836 	_asm ret

   837 

   838 	// dividend=NaN or infinity

   839 	modfpss:

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

   841 	_asm mov edi, [esi+4]

   842 	_asm cmp edi, 0x80000000	// check for infinity

   843 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   844 	_asm test ebp, ebp

   845 	_ASM_jn(e,TRealXBinOpNaN)

   846 	_asm cmp ecx, 0xFFFF0000	// check divisor for NaN or infinity

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

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

   849 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   850 	_asm test ebx, ebx

   851 	_ASM_jn(e,TRealXBinOpNaN)

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

   853 

   854 	// divisor=NaN or infinity, dividend finite

   855 	modfpsd:

   856 	_asm cmp edx, 0x80000000	// check for infinity

   857 	_ASM_jn(e,TRealXBinOpNaN)	// branch if NaN

   858 	_asm test ebx, ebx

   859 	_ASM_jn(e,TRealXBinOpNaN)

   860 	// finite%infinity - return dividend unaltered

   861 

   862 	modfpdd0:

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

   864 	_asm mov edx, [esi+4]

   865 	_asm mov ecx, [esi+8]

   866 	_asm xor eax, eax

   867 	_asm ret

   868 

   869 	modfp0:

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

   871 	_asm xor eax, eax

   872 	_asm ret

   873 

   874 	modfpund:

   875 	_asm shr ecx, 16			// underflow, result 0

   876 	_asm mov eax, -10			// return KErrUnderflow

   877 	_asm ret

   878 

   879 	modfplp:

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

   881 	_asm mov eax, -7			// return KErrTotalLossOfPrecision

   882 	_asm ret

   883 	}

   884 

   885 

   886 

   887 

   888 __NAKED__ EXPORT_C TRealX::TRealX()

   889 /**

   890 Constructs a default extended precision object.

   891 

   892 This sets the value to zero.

   893 */

   894 	{

   895 	_asm xor eax, eax

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

   897 	_asm mov [ecx+4], eax

   898 	_asm mov [ecx+8], eax

   899 	_asm mov eax, ecx			// must return this

   900 	_asm ret

   901 	}

   902 

   903 

   904 

   905 

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

   907 /**

   908 Constructs an extended precision object from an explicit exponent and

   909 a 64 bit mantissa.

   910 

   911 @param aExp    The exponent 

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

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

   914 */

   915 	{

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

   917 	_asm mov [ecx+8], eax

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

   919 	_asm mov [ecx+4], eax

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

   921 	_asm mov [ecx], eax

   922 	_asm mov eax, ecx			// must return this

   923 	_asm ret 12

   924 	}

   925 

   926 

   927 

   928 

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

   930 /**

   931 Gives this extended precision object a new value taken

   932 from a signed integer.

   933 

   934 @param aInt The signed integer value.

   935 

   936 @return KErrNone, always.

   937 */

   938 	{

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

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

   941 	_asm or edx, edx			// test sign/zero

   942 	_asm mov eax, 0x7FFF

   943 	_asm jz short trealxfromint0	// branch if 0

   944 	_asm jns short trealxfromint1	// skip if positive

   945 	_asm neg edx					// take absolute value

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

   947 	trealxfromint1:

   948 	_asm push ecx					// save this

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

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

   951 	_asm neg cl

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

   953 	_asm shl edx, cl				// normalise edx

   954 	_asm pop ecx					// this back into ecx

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

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

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

   958 	_asm xor eax, eax

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

   960 	_asm ret 4						// return KErrNone

   961 	trealxfromint0:

   962 	_asm mov [ecx], edx

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

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

   965 	_asm xor eax, eax				// return KErrNone

   966 	_asm ret 4

   967 	}

   968 

   969 

   970 

   971 

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

   973 /**

   974 Gives this extended precision object a new value taken from

   975 an unsigned integer.

   976 

   977 @param aInt The unsigned integer value.

   978 

   979 @return KErrNone, always.

   980 */

   981 	{

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

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

   984 	_asm mov eax, 0x7FFF

   985 	_asm or edx, edx				// test for 0

   986 	_asm jz short trealxfromuint0	// branch if 0

   987 	_asm push ecx					// save this

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

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

   990 	_asm neg cl

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

   992 	_asm shl edx, cl				// normalise edx

   993 	_asm pop ecx					// this back into ecx

   994 	_asm shl eax, 16				// exponent into normal position

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

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

   997 	_asm xor eax, eax

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

   999 	_asm ret 4						// return KErrNone

  1000 	trealxfromuint0:

  1001 	_asm mov [ecx], edx

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

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

  1004 	_asm xor eax, eax				// return KErrNone

  1005 	_asm ret 4

  1006 	}

  1007 

  1008 

  1009 

  1010 

  1011 __NAKED__ LOCAL_C void TRealXFromTInt64(void)

  1012 	{

  1013 	// Convert TInt64 in edx:ebx to TRealX in ecx,edx:ebx

  1014 	_asm mov eax, 0x7FFF

  1015 	_asm or edx, edx				// test sign/zero

  1016 	_asm jz short trealxfromtint64a	// branch if top word zero

  1017 	_asm jns short trealxfromtint64b

  1018 	_asm add eax, 0x10000			// sign bit into eax bit 16

  1019 	_asm neg edx					// take absolute value

  1020 	_asm neg ebx

  1021 	_asm sbb edx, 0

  1022 	_asm jz short trealxfromtint64d	// branch if top word zero

  1023 	trealxfromtint64b:

  1024 	_asm bsr ecx, edx				// ecx=bit number of edx MSB

  1025 	_asm add eax, ecx				// add to exponent in eax

  1026 	_asm add eax, 32

  1027 	_asm neg cl

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

  1029 	_asm shld edx, ebx, cl			// shift left to normalise edx:ebx

  1030 	_asm shl ebx, cl

  1031 	_asm mov ecx, eax				// sign/exponent into ecx

  1032 	_asm ror ecx, 16				// and into normal positions

  1033 	_asm ret

  1034 	trealxfromtint64a:				// come here if top word zero

  1035 	_asm or ebx, ebx				// test for bottom word also zero

  1036 	_asm jz short trealxfromtint64c	// branch if it is

  1037 	trealxfromtint64d:				// come here if top word zero, bottom word not

  1038 	_asm mov edx, ebx				// shift edx:ebx left 32

  1039 	_asm xor ebx, ebx

  1040 	_asm bsr ecx, edx				// ecx=bit number of edx MSB

  1041 	_asm add eax, ecx				// add to exponent in eax

  1042 	_asm neg cl

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

  1044 	_asm shl edx, cl				// normalise

  1045 	_asm mov ecx, eax				// sign/exponent into ecx

  1046 	_asm ror ecx, 16				// and into normal positions

  1047 	_asm ret

  1048 	trealxfromtint64c:				// entire number is zero

  1049 	_asm xor ecx, ecx

  1050 	_asm ret

  1051 	}

  1052 

  1053 

  1054 

  1055 

  1056 __NAKED__ EXPORT_C TInt TRealX::Set(const TInt64& /*aInt*/)

  1057 /**

  1058 Gives this extended precision object a new value taken from

  1059 a 64 bit integer.

  1060 

  1061 @param aInt The 64 bit integer value.

  1062 

  1063 @return KErrNone, always.

  1064 */

  1065 	{

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

  1067 	_asm push ebx

  1068 	_asm push ecx

  1069 	_asm mov edx, [esp+12]		// edx=address of aInt

  1070 	_asm mov ebx, [edx]

  1071 	_asm mov edx, [edx+4]		// edx:ebx=aInt

  1072 	_asm call TRealXFromTInt64	// convert to TRealX in ecx,edx:ebx

  1073 	_asm pop eax				// eax=this

  1074 	_asm mov [eax], ebx			// store result

  1075 	_asm mov [eax+4], edx

  1076 	_asm mov [eax+8], ecx

  1077 	_asm xor eax, eax			// return KErrNone

  1078 	_asm pop ebx

  1079 	_asm ret 4

  1080 	}

  1081 

  1082 

  1083 

  1084 

  1085 __NAKED__ LOCAL_C void __6TRealXi()

  1086 	{

  1087 	// common function for int to TRealX

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

  1089 	_asm or edx, edx			// test sign/zero

  1090 	_asm mov eax, 0x7FFF

  1091 	_asm jz short trealxfromint0	// branch if 0

  1092 	_asm jns short trealxfromint1	// skip if positive

  1093 	_asm neg edx					// take absolute value

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

  1095 	trealxfromint1:

  1096 	_asm push ecx					// save this

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

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

  1099 	_asm neg cl

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

  1101 	_asm shl edx, cl				// normalise edx

  1102 	_asm pop ecx					// this back into ecx

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

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

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

  1106 	_asm xor eax, eax

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

  1108 	_asm mov eax, ecx				// return eax=this

  1109 	_asm ret 4

  1110 	trealxfromint0:

  1111 	_asm mov [ecx], edx

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

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

  1114 	_asm mov eax, ecx				// return eax=this

  1115 	_asm ret 4

  1116 	}

  1117 

  1118 

  1119 

  1120 

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

  1122 /**

  1123 Constructs an extended precision object from a signed integer value.

  1124 

  1125 @param aInt The signed integer value.

  1126 */

  1127 	{

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

  1129 	_asm jmp __6TRealXi

  1130 	}

  1131 

  1132 

  1133 

  1134 

  1135 __NAKED__ EXPORT_C TRealX& TRealX::operator=(TInt /*aInt*/)