1 // Copyright (c) 2007-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 "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

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

    15 // 

    16 //

    17 

    18 

    19 #include "u32std.h"

    20 #include <e32math.h>

    21 

    22 

    23 void TRealXPanic(TInt aErr);

    24 

    25 LOCAL_C __NAKED__ void TRealXPanicEax(void)

    26 	{

    27 	asm("push eax");

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

    29 	}

    30 

    31 LOCAL_C __NAKED__ void TRealXRealIndefinite(void)

    32 	{

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

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

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

    36 	asm("xor ebx, ebx");

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

    38 	asm("ret");

    39 	}

    40 

    41 LOCAL_C __NAKED__ void TRealXBinOpNaN(void)

    42 	{

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

    44 	// destination operand in ecx,edx:eax

    45 	// source operand at [esi]

    46 

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

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

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

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

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

    52 	asm("cmp edx, 0x80000000");

    53 	asm("jne short TRealXBinOpNaN2");

    54 	asm("test ebx, ebx");

    55 	asm("jne short TRealXBinOpNaN2");

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

    57 	asm("xchg ecx, eax");

    58 	asm("xchg edx, edi");

    59 	asm("xchg ebx, ebp");

    60 	asm("TRealXBinOpNaN2:");

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

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

    63 	asm("cmp edi, 0x80000000");

    64 	asm("jne short TRealXBinOpNaN3");

    65 	asm("test ebp, ebp");

    66 	asm("je short TRealXBinOpNaN4");

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

    68 	asm("cmp edx, edi");

    69 	asm("ja short TRealXBinOpNaN4");

    70 	asm("jb short TRealXBinOpNaN5");

    71 	asm("cmp ebx, ebp");

    72 	asm("jae short TRealXBinOpNaN4");

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

    74 	asm("mov ecx, eax");

    75 	asm("mov edx, edi");

    76 	asm("mov ebx, ebp");

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

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

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

    80 	asm("ret");

    81 	}

    82 

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

    84 // Result in ecx,edx:ebx

    85 // Error code in eax

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

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

    88 LOCAL_C __NAKED__ void TRealXAdd()

    89 	{

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

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

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

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

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

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

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

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

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

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

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

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

   102 	asm("mov ch, cl");

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

   104 	asm("add ch, ch");

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

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

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

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

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

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

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

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

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

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

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

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

   117 	asm("xchg edx, edi");			

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

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

   120 	asm("addfp1:");

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

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

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

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

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

   126 	asm("jz short addfp3a");

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

   128 	asm("addfp3a:");

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

   130 	asm("xor ebp, ebp");			

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

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

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

   134 	asm("jmp short addfp5");

   135 	asm("addfp3:");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   156 

   157 	asm("addfp5:");

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

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

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

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

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

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

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

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

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

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

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

   169 	asm("jnc short addfp5a");

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

   171 	asm("addfp5a:");

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

   173 

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

   175 	asm("roundfp:");

   176 	asm("cmp eax, 0x80000000");		

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

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

   179 	asm("test ch, 1");

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

   181 	asm("test ch, 2");

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

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

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

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

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

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

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

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

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

   191 	asm("roundfp1a:");

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

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

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

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

   196 	asm("ret");

   197 

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

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

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

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

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

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

   204 	asm("roundfp0a:");				

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

   206 	asm("ret");

   207 

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

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

   210 	asm("xor ebx, ebx");

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

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

   213 	asm("ret");

   214 

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

   216 	asm("addfp2:");					

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

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

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

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

   221 	asm("jz addfp2a");

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

   223 	asm("addfp2a:");

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

   225 	asm("ret");

   226 

   227 	// signs differ, so must subtract mantissas

   228 	asm("subfp1:");

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

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

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

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

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

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

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

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

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

   238 	asm("not edx");					//

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

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

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

   242 	asm("subfp2:");

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

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

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

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

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

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

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

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

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

   252 	asm("subfp4:");

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

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

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

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

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

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

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

   260 	asm("subfp3:");

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

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

   263 	asm("neg ecx");					//

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

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

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

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

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

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

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

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

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

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

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

   275 

   276 	// come here if underflow

   277 	asm("subfpundflw:");			

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

   279 	asm("xor edx, edx");

   280 	asm("xor ebx, ebx");

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

   282 	asm("ret");

   283 

   284 	// come here to return zero result

   285 	asm("subfp0:");

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

   287 	asm("xor edx, edx");

   288 	asm("xor ebx, ebx");

   289 	asm("addfp0snzd:");

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

   291 	asm("ret");

   292 

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

   294 	asm("addfp0s:");

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

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

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

   298 	asm("and ecx, 1");

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

   300 	asm("ret");

   301 

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

   303 	asm("addfp0d:");

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

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

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

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

   308 	asm("ret");

   309 

   310 	// come here if dest=NaN or infinity

   311 	asm("addfpsd:");

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

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

   314 	asm("test ebx, ebx");

   315 	_ASM_jn(e,TRealXBinOpNaN)

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

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

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

   319 	asm("addfpsd2:");

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

   321 	asm("ret");

   322 	asm("addfpsd1:");

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

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

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

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

   327 	asm("test ebp, ebp");

   328 	_ASM_jn(e,TRealXBinOpNaN)

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

   330 	asm("test al, 1");

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

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

   333 

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

   335 	asm("addfpss:");

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

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

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

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

   340 	asm("test ebp, ebp");

   341 	_ASM_jn(e,TRealXBinOpNaN)

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

   343 	asm("mov edx, edi");

   344 	asm("mov ebx, ebp");

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

   346 	asm("ret");

   347 	}

   348 

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

   350 // Result in ecx,edx:ebx

   351 // Error code in eax

   352 LOCAL_C __NAKED__ void TRealXSubtract()

   353 	{

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

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

   356 	}

   357 

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

   359 // Result in ecx,edx:ebx

   360 // Error code in eax

   361 LOCAL_C __NAKED__ void TRealXMultiply()

   362 	{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   400 	asm("mov edi, ebx");			

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

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

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

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

   405 	asm("adc ebp, ebp");

   406 	asm("adc ebx, ebx");

   407 	asm("adc edx, edx");

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

   409 	asm("mulfp1:");

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

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

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

   413 	asm("test edi, edi");

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

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

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

   417 	asm("mulfp2:");

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

   419 	asm("adc edx, 0");

   420 	asm("jnc short mulfp2a");

   421 	asm("rcr edx, 1");

   422 	asm("inc ecx");	

   423 	asm("mulfp2a:");

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

   425 	asm("jmp short mulfp5");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   442 	asm("ret");

   443 

   444 	// come here if overflow

   445 	asm("mulfp6:");					

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

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

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

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

   450 	asm("xor ebx, ebx");

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

   452 	asm("ret");

   453 

   454 	// come here if underflow

   455 	asm("mulfp7:");				

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

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

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

   459 	asm("xor edx, edx");

   460 	asm("xor ebx, ebx");

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

   462 	asm("ret");

   463 

   464 	// come here if either operand zero

   465 	asm("mulfp0:");

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

   467 	asm("xor edx, edx");

   468 	asm("xor ebx, ebx");

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

   470 	asm("ret");

   471 

   472 	// come here if destination operand NaN or infinity

   473 	asm("mulfpsd:");

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

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

   476 	asm("test ebx, ebx");

   477 	_ASM_jn(e,TRealXBinOpNaN)

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

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

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

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

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

   483 	asm("ret");

   484 	asm("mulfpsd1:");

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

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

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

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

   489 	asm("test ebp, ebp");

   490 	_ASM_jn(e,TRealXBinOpNaN)

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

   492 	asm("ret");						// and KErrOverflow

   493 

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

   495 	asm("mulfpss:");

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

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

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

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

   500 	asm("test ebp, ebp");

   501 	_ASM_jn(e,TRealXBinOpNaN)

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

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

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

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

   506 	asm("mov ebx, ebp");

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

   508 	asm("ret");

   509 	}

   510 

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

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

   513 // Assume the quotient fits in 32 bits

   514 // Return 32 bit quotient in EDI

   515 // Return 64 bit remainder in EBP:ESI

   516 LOCAL_C __NAKED__ void LongDivide(void)

   517 	{

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

   519 	asm("push eax");				//

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

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

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

   523 	asm("dec eax");					//

   524 	asm("jmp short longdiv2");		//

   525 	asm("longdiv1:");

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

   527 	asm("longdiv2:");

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

   529 	asm("mul ebx");					// multiply approx quotient by full divisor ECX:EBX

   530 	asm("mov esi, eax");			// first partial product into EBP:ESI

   531 	asm("mov ebp, edx");			//

   532 	asm("mov eax, edi");			// approx quotient back into eax

   533 	asm("mul ecx");					// upper partial product now in EDX:EAX

   534 	asm("add eax, ebp");			// add to form 96-bit product in EDX:EAX:ESI

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

   536 	asm("neg esi");					// remainder = dividend - approx quotient * divisor

   537 	asm("mov ebp, [esp]");			// fetch dividend bits 32-63

   538 	asm("sbb ebp, eax");			//

   539 	asm("mov eax, [esp+4]");		// fetch dividend bits 64-95

   540 	asm("sbb eax, edx");			// remainder is now in EAX:EBP:ESI

   541 	asm("jns short longdiv4");		// if remainder positive, quotient is correct, so exit

   542 	asm("longdiv3:");

   543 	asm("dec edi");					// else quotient is too big, so decrement it

   544 	asm("add esi, ebx");			// and add divisor to remainder

   545 	asm("adc ebp, ecx");			//

   546 	asm("adc eax, 0");				//

   547 	asm("js short longdiv3");		// if still negative, repeat [requires <4 iterations]

   548 	asm("longdiv4:");

   549 	asm("add esp, 8");				// remove dividend from stack

   550 	asm("ret");						// return with quotient in EDI, remainder in EBP:ESI

   551 	}

   552 

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

   554 // Result in ecx,edx:ebx

   555 // Error code in eax

   556 LOCAL_C __NAKED__ void TRealXDivide(void)

   557 	{

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

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

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

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

   562 	asm("jnc divfpss");				// branch if it is

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

   564 	asm("jnc divfpsd");				// branch if it is

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

   566 	asm("jc divfpdv0");				// branch if it is

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

   568 	asm("jc divfpdd0");				// branch if it is

   569 	asm("push esi");				// save pointer to dividend

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

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

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

   573 	asm("sub eax, ecx");			// subtract exponents

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

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

   576 	asm("mov ecx, edx");			// divisor mantissa into ecx:ebx

   577 	asm("mov edx, [esi+4]");		// dividend mantissa into edx:eax

   578 	asm("mov eax, [esi]");			

   579 	asm("xor edi, edi");			// clear edi initially

   580 	asm("cmp edx, ecx");			// compare EDX:EAX with ECX:EBX

   581 	asm("jb short divfp1");			// if EDX:EAX < ECX:EBX, leave everything as is

   582 	asm("ja short divfp2");			//

   583 	asm("cmp eax, ebx");			// if EDX=ECX, then compare ls dwords

   584 	asm("jb short divfp1");			// if dividend mant < divisor mant, leave everything as is

   585 	asm("divfp2:");

   586 	asm("sub eax, ebx");			// else dividend mant -= divisor mant

   587 	asm("sbb edx, ecx");			//

   588 	asm("inc edi");					// and EDI=1 [bit 0 of EDI is the integer part of the result]

   589 	asm("inc dword ptr [esp]");		// also increment result exponent

   590 	asm("divfp1:");

   591 	asm("push edi");				// save top bit of result

   592 	asm("call %a0": : "i"(&LongDivide));	// divide EDX:EAX:0 by ECX:EBX to give next 32 bits of result in EDI

   593 	asm("push edi");				// save next 32 bits of result

   594 	asm("mov edx, ebp");			// remainder from EBP:ESI into EDX:EAX

   595 	asm("mov eax, esi");			//

   596 	asm("call %a0": : "i"(&LongDivide));	// divide EDX:EAX:0 by ECX:EBX to give next 32 bits of result in EDI

   597 	asm("test byte ptr [esp+4], 1");	// test integer bit of result

   598 	asm("jnz short divfp4");		// if set, no need to calculate another bit

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

   600 	asm("add esi, esi");			// 2*remainder into EAX:EBP:ESI

   601 	asm("adc ebp, ebp");			//

   602 	asm("adc eax, eax");			//

   603 	asm("sub esi, ebx");			// subtract divisor to generate final quotient bit

   604 	asm("sbb ebp, ecx");			//

   605 	asm("sbb eax, 0");				//

   606 	asm("jnc short divfp3");		// skip if no borrow - in this case eax=0

   607 	asm("add esi, ebx");			// if borrow add back - final remainder now in EBP:ESI

   608 	asm("adc ebp, ecx");			//

   609 	asm("adc eax, 0");				// eax will be zero after this and carry will be set

   610 	asm("divfp3:");

   611 	asm("cmc");						// final bit = 1-C

   612 	asm("rcr eax, 1");				// shift it into eax bit 31

   613 	asm("mov ebx, edi");			// result into EDX:EBX:EAX, remainder in EBP:ESI

   614 	asm("pop edx");

   615 	asm("add esp, 4");				// discard integer bit [zero]

   616 	asm("jmp short divfp5");		// branch to round

   617 

   618 	asm("divfp4:");					// integer bit was set

   619 	asm("mov ebx, edi");			// result into EDX:EBX:EAX

   620 	asm("pop edx");					//

   621 	asm("pop eax");					// integer part of result into eax [=1]

   622 	asm("stc");						// shift a 1 into top end of mantissa

   623 	asm("rcr edx,1");				//

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

   625 	asm("rcr eax,1");				// bottom bit into eax bit 31

   626 

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

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

   629 	// and the remainder is in EBP:ESI

   630 	asm("divfp5:");

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

   632 	asm("add eax, eax");			// test rounding bit

   633 	asm("jnc short divfp6");		// branch to round down

   634 	asm("or ebp, esi");				// test remainder to see if we are exactly half-way

   635 	asm("jnz short divfp7");		// if not, round up

   636 	asm("test bl, 1");				// exactly halfway - test LSB of mantissa

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

   638 	asm("divfp7:");

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

   640 	asm("adc edx, 0");

   641 	asm("jnc short divfp7a");

   642 	asm("rcr edx, 1");				// if carry, shift 1 into mantissa MSB

   643 	asm("inc ecx");					// and increment exponent

   644 	asm("divfp7a:");

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

   646 	asm("jmp short divfp9");

   647 	asm("divfp6:");

   648 	asm("xor al, al");				// round down - first clear rounding flags

   649 	asm("or ebp, esi");				// test if result exact

   650 	asm("jz short divfp9");			// skip if exact

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

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

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

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

   655 	asm("jge short divfp10");		// branch if overflow

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

   657 	asm("jle short divfp11");		// branch if underflow

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

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

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

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

   662 	asm("pop esi");					// recover dividend pointer

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

   664 	asm("ret");

   665 

   666 	// come here if overflow

   667 	asm("divfp10:");

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

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

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

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

   672 	asm("xor ebx, ebx");

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

   674 	asm("pop esi");					// recover dividend pointer

   675 	asm("ret");

   676 

   677 	// come here if underflow

   678 	asm("divfp11:");	

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

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

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

   682 	asm("xor edx, edx");

   683 	asm("xor ebx, ebx");

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

   685 	asm("pop esi");					// recover dividend pointer

   686 	asm("ret");

   687 

   688 

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

   690 	asm("divfpdv0:");

   691 	asm("cmp eax, 0x10000");		// check if dividend also zero

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

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

   694 	asm("mov edx, 0x80000000");		// set mantissa for infinity

   695 	asm("xor ebx, ebx");

   696 	asm("mov eax, -41");			// return KErrDivideByZero

   697 	asm("ret");

   698 

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

   700 	asm("divfpdd0:");

   701 	asm("and ecx, 1");				// exponent=0, leave xor sign in cl

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

   703 	asm("ret");

   704 

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

   706 	asm("divfpss:");

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

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

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

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

   711 	asm("test ebp, ebp");

   712 	_ASM_jn(e,TRealXBinOpNaN)

   713 	asm("cmp ecx, 0xFFFF0000");		// check divisor for NaN or infinity

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

   715 	asm("or ecx, 0xFFFF0000");		// infinity/finite - return infinity with xor sign

   716 	asm("mov edx, 0x80000000");

   717 	asm("xor ebx, ebx");

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

   719 	asm("ret");

   720 	asm("divfpss1:");

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

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

   723 	asm("test ebx, ebx");

   724 	_ASM_jn(e,TRealXBinOpNaN)

   725 	asm("jmp %a0": : "i"(&TRealXRealIndefinite)); // if both operands infinite, return 'real indefinite'

   726 

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

   728 	asm("divfpsd:");

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

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

   731 	asm("test ebx, ebx");

   732 	_ASM_jn(e,TRealXBinOpNaN)

   733 	asm("and ecx, 1");				// dividend is finite, divisor=infinity, so return 0 with xor sign

   734 	asm("xor edx, edx");

   735 	asm("xor ebx, ebx");

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

   737 	asm("ret");

   738 	}

   739 

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

   741 // Result in ecx,edx:ebx

   742 // Error code in eax

   743 LOCAL_C __NAKED__ void TRealXModulo(void)

   744 	{

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

   746 	asm("mov cl, al");				// result sign=dividend sign

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

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

   749 	asm("jnc short modfpss");		// branch if it is

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

   751 	asm("jnc short modfpsd");		// branch if it is

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

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

   754 	asm("shr eax, 16");				// ax=dividend exponent

   755 	asm("ror ecx, 16");				// cx=divisor exponent

   756 	asm("sub ax, cx");				// ax=dividend exponent-divisor exponent

   757 	asm("jc short modfpdd0");		// if dividend exponent is smaller, return dividend

   758 	asm("cmp ax, 64");				// check if exponents differ by >= 64 bits

   759 	asm("jnc short modfplp");		// if so, underflow

   760 	asm("mov ah, 0");				// ah bit 0 acts as 65th accumulator bit

   761 	asm("mov ebp, [esi]");			// edi:ebp=dividend mantissa

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

   763 	asm("jmp short modfp2");		// skip left shift on first iteration

   764 	asm("modfp1:");

   765 	asm("add ebp, ebp");			// shift accumulator left [65 bits]

   766 	asm("adc edi, edi");

   767 	asm("adc ah, ah");

   768 	asm("modfp2:");

   769 	asm("sub ebp, ebx");			// subtract divisor from dividend

   770 	asm("sbb edi, edx");

   771 	asm("sbb ah, 0");

   772 	asm("jnc short modfp3");		// skip if no borrow

   773 	asm("add ebp, ebx");			// else add back

   774 	asm("adc edi, edx");

   775 	asm("adc ah, 0");

   776 	asm("modfp3:");

   777 	asm("dec al");					// any more bits to do?

   778 	asm("jns short modfp1");		// loop if there are

   779 	asm("mov edx, edi");			// result mantissa [not yet normalised] into edx:ebx

   780 	asm("mov ebx, ebp");

   781 	asm("or edi, ebx");				// check for zero

   782 	asm("jz short modfp0");			// jump if result zero

   783 	asm("or edx, edx");				// check if ms dword zero

   784 	asm("jnz short modfp4");

   785 	asm("mov edx, ebx");			// if so, shift left by 32

   786 	asm("xor ebx, ebx");

   787 	asm("sub cx, 32");				// and decrement exponent by 32

   788 	asm("jbe short modfpund");		// if borrow or exponent zero, underflow

   789 	asm("modfp4:");

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

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

   792 	asm("neg ecx");					//

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

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

   795 	asm("shl ebx, cl");				//

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

   797 	asm("mov ecx, edi");			// exponent & sign back into ecx

   798 	asm("sub cx, bp");				// subtract shift count from exponent

   799 	asm("jbe short modfpund");		// if borrow or exponent 0, underflow

   800 	asm("rol ecx, 16");				// else ecx=exponent:sign

   801 	asm("xor eax, eax");			// normal exit, result in ecx,edx:ebx

   802 	asm("ret");

   803 

   804 	// dividend=NaN or infinity

   805 	asm("modfpss:");

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

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

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

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

   810 	asm("test ebp, ebp");

   811 	_ASM_jn(e,TRealXBinOpNaN)

   812 	asm("cmp ecx, 0xFFFF0000");		// check divisor for NaN or infinity

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

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

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

   816 	asm("test ebx, ebx");

   817 	_ASM_jn(e,TRealXBinOpNaN)

   818 	asm("jmp %a0": : "i"(&TRealXRealIndefinite));	// if both operands infinite, return 'real indefinite'

   819 

   820 	// divisor=NaN or infinity, dividend finite

   821 	asm("modfpsd:");

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

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

   824 	asm("test ebx, ebx");

   825 	_ASM_jn(e,TRealXBinOpNaN)

   826 	// finite%infinity - return dividend unaltered

   827 

   828 	asm("modfpdd0:");

   829 	asm("mov ebx, [esi]");			// normal exit, return dividend unaltered

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

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

   832 	asm("xor eax, eax");

   833 	asm("ret");

   834 

   835 	asm("modfp0:");

   836 	asm("shr ecx, 16");				// normal exit, result 0

   837 	asm("xor eax, eax");

   838 	asm("ret");

   839 

   840 	asm("modfpund:");

   841 	asm("shr ecx, 16");				// underflow, result 0

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

   843 	asm("ret");

   844 

   845 	asm("modfplp:");

   846 	asm("shr ecx, 16");				// loss of precision, result 0

   847 	asm("mov eax, -7");				// return KErrTotalLossOfPrecision

   848 	asm("ret");

   849 	}

   850 

   851 

   852 

   853 

   854 __NAKED__ EXPORT_C TRealX::TRealX()

   855 /**

   856 Constructs a default extended precision object.

   857 

   858 This sets the value to zero.

   859 */

   860 	{

   861 	THISCALL_PROLOG0()

   862 	asm("xor eax, eax");

   863 	asm("mov [ecx], eax");				// set value to zero

   864 	asm("mov [ecx+4], eax");

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

   866 	asm("mov eax, ecx");				// must return this

   867 	THISCALL_EPILOG0()

   868 	}

   869 

   870 

   871 

   872 

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

   874 /**

   875 Constructs an extended precision object from an explicit exponent and

   876 a 64 bit mantissa.

   877 

   878 @param aExp    The exponent

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

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

   881 */

   882 	{

   883 	THISCALL_PROLOG3()

   884 	asm("mov eax, [esp+4]");			// eax=aExp

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

   886 	asm("mov eax, [esp+8]");			// eax=aMantHi

   887 	asm("mov [ecx+4], eax");

   888 	asm("mov eax, [esp+12]");			// eax=aMantLo

   889 	asm("mov [ecx], eax");

   890 	asm("mov eax, ecx");				// must return this

   891 	THISCALL_EPILOG3()

   892 	}

   893 

   894 

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

   896 /**

   897 Gives this extended precision object a new value taken

   898 from a signed integer.

   899 

   900 @param aInt The signed integer value.

   901 

   902 @return KErrNone, always.

   903 */

   904 	{

   905 	THISCALL_PROLOG1()

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

   907 	asm("mov edx, [esp+4]");	// edx=aInt

   908 	asm("or edx, edx");			// test sign/zero

   909 	asm("mov eax, 0x7FFF");

   910 	asm("jz short trealxfromint0_2");	// branch if 0

   911 	asm("jns short trealxfromint1_2");// skip if positive

   912 	asm("neg edx");					// take absolute value

   913 	asm("add eax, 0x10000");		// sign bit in eax bit 16

   914 	asm("trealxfromint1_2:");

   915 	asm("push ecx");				// save this

   916 	asm("bsr ecx, edx");			// bit number of edx MSB into ecx

   917 	asm("add eax, ecx");			// add to eax to form result exponent

   918 	asm("neg cl");

   919 	asm("add cl, 31");				// 31-bit number = number of shifts to normalise edx

   920 	asm("shl edx, cl");				// normalise edx

   921 	asm("pop ecx");					// this back into ecx

   922 	asm("ror eax, 16");				// sign/exponent into normal positions

   923 	asm("mov [ecx+4], edx");		// store mantissa high word

   924 	asm("mov [ecx+8], eax");		// store sign/exponent

   925 	asm("xor eax, eax");

   926 	asm("mov [ecx], eax");			// zero mantissa low word

   927 	THISCALL_EPILOG1()					// return KErrNone

   928 	asm("trealxfromint0_2:");

   929 	asm("mov [ecx], edx");

   930 	asm("mov [ecx+4], edx");		// store mantissa high word=0

   931 	asm("mov [ecx+8], edx");		// store sign/exponent=0

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

   933 	THISCALL_EPILOG1()

   934 	}

   935 

   936 

   937 

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

   939 /**

   940 Gives this extended precision object a new value taken from

   941 an unsigned integer.

   942 

   943 @param aInt The unsigned integer value.

   944 

   945 @return KErrNone, always.

   946 */

   947 	{

   948 	THISCALL_PROLOG1()

   949 	asm("mov edx, [esp+4]");		// edx=aInt

   950 	asm("mov eax, 0x7FFF");

   951 	asm("or edx, edx");				// test for 0

   952 	asm("jz short trealxfromuint0_");// branch if 0

   953 	asm("push ecx");				// save this

   954 	asm("bsr ecx, edx");			// bit number of edx MSB into ecx

   955 	asm("add eax, ecx");			// add to eax to form result exponent

   956 	asm("neg cl");

   957 	asm("add cl, 31");				// 31-bit number = number of shifts to normalise edx

   958 	asm("shl edx, cl");				// normalise edx

   959 	asm("pop ecx");					// this back into ecx

   960 	asm("shl eax, 16");				// exponent into normal position

   961 	asm("mov [ecx+4], edx");		// store mantissa high word

   962 	asm("mov [ecx+8], eax");		// store exponent

   963 	asm("xor eax, eax");

   964 	asm("mov [ecx], eax");			// zero mantissa low word

   965 	THISCALL_EPILOG1()				// return KErrNone

   966 	asm("trealxfromuint0_:");

   967 	asm("mov [ecx], edx");

   968 	asm("mov [ecx+4], edx");		// store mantissa high word=0

   969 	asm("mov [ecx+8], edx");		// store sign/exponent=0

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

   971 	THISCALL_EPILOG1()

   972 	}

   973 

   974 

   975 

   976 

   977 LOCAL_C __NAKED__ void TRealXFromTInt64(void)

   978 	{

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

   980 	asm("mov eax, 0x7FFF");

   981 	asm("or edx, edx");					// test sign/zero

   982 	asm("jz short trealxfromtint64a");	// branch if top word zero

   983 	asm("jns short trealxfromtint64b");

   984 	asm("add eax, 0x10000");			// sign bit into eax bit 16

   985 	asm("neg edx");						// take absolute value

   986 	asm("neg ebx");

   987 	asm("sbb edx, 0");

   988 	asm("jz short trealxfromtint64d");	// branch if top word zero

   989 	asm("trealxfromtint64b:");

   990 	asm("bsr ecx, edx");				// ecx=bit number of edx MSB

   991 	asm("add eax, ecx");				// add to exponent in eax

   992 	asm("add eax, 32");

   993 	asm("neg cl");

   994 	asm("add cl, 31");					// 31-bit number = number of left shifts to normalise

   995 	asm("shld edx, ebx, cl");			// shift left to normalise edx:ebx

   996 	asm("shl ebx, cl");

   997 	asm("mov ecx, eax");				// sign/exponent into ecx

   998 	asm("ror ecx, 16");					// and into normal positions

   999 	asm("ret");

  1000 	asm("trealxfromtint64a:");			// come here if top word zero

  1001 	asm("or ebx, ebx");					// test for bottom word also zero

  1002 	asm("jz short trealxfromtint64c");	// branch if it is

  1003 	asm("trealxfromtint64d:");			// come here if top word zero, bottom word not

  1004 	asm("mov edx, ebx");				// shift edx:ebx left 32

  1005 	asm("xor ebx, ebx");

  1006 	asm("bsr ecx, edx");				// ecx=bit number of edx MSB

  1007 	asm("add eax, ecx");				// add to exponent in eax

  1008 	asm("neg cl");

  1009 	asm("add cl, 31");					// 31-bit number = number of left shifts to normalise

  1010 	asm("shl edx, cl");					// normalise

  1011 	asm("mov ecx, eax");				// sign/exponent into ecx

  1012 	asm("ror ecx, 16");					// and into normal positions

  1013 	asm("ret");

  1014 	asm("trealxfromtint64c:");			// entire number is zero

  1015 	asm("xor ecx, ecx");

  1016 	asm("ret");

  1017 	}

  1018 

  1019 

  1020 

  1021 

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

  1023 /**

  1024 Gives this extended precision object a new value taken from

  1025 a 64 bit integer.

  1026 

  1027 @param aInt The 64 bit integer value.

  1028 

  1029 @return KErrNone, always.

  1030 */

  1031 	{

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

  1033 	THISCALL_PROLOG1()

  1034 	asm("push ebx");

  1035 	asm("push ecx");

  1036 	asm("mov edx, [esp+12]");			// edx=address of aInt

  1037 	asm("mov ebx, [edx]");

  1038 	asm("mov edx, [edx+4]");			// edx:ebx=aInt

  1039 	asm("call %a0": : "i"(&TRealXFromTInt64)); // convert to TRealX in ecx,edx:ebx

  1040 	asm("pop eax");						// eax=this

  1041 	asm("mov [eax], ebx");				// store result

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

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

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

  1045 	asm("pop ebx");

  1046 	THISCALL_EPILOG1()

  1047 	}

  1048 

  1049 

  1050 

  1051 LOCAL_C __NAKED__ void __6TRealXi()

  1052 	{

  1053 	// common function for int to TRealX

  1054 	THISCALL_PROLOG1()

  1055 	asm("mov edx, [esp+4]");			// edx=aInt

  1056 	asm("or edx, edx");					// test sign/zero

  1057 	asm("mov eax, 0x7FFF");

  1058 	asm("jz short trealxfromint0");		// branch if 0

  1059 	asm("jns short trealxfromint1");	// skip if positive

  1060 	asm("neg edx");						// take absolute value

  1061 	asm("add eax, 0x10000");			// sign bit in eax bit 16

  1062 	asm("trealxfromint1:");

  1063 	asm("push ecx");					// save this

  1064 	asm("bsr ecx, edx");				// bit number of edx MSB into ecx

  1065 	asm("add eax, ecx");				// add to eax to form result exponent

  1066 	asm("neg cl");

  1067 	asm("add cl, 31");					// 31-bit number = number of shifts to normalise edx

  1068 	asm("shl edx, cl");					// normalise edx

  1069 	asm("pop ecx");						// this back into ecx

  1070 	asm("ror eax, 16");					// sign/exponent into normal positions

  1071 	asm("mov [ecx+4], edx");			// store mantissa high word

  1072 	asm("mov [ecx+8], eax");			// store sign/exponent

  1073 	asm("xor eax, eax");

  1074 	asm("mov [ecx], eax");				// zero mantissa low word

  1075 	asm("mov eax, ecx");				// return eax=this

  1076 	THISCALL_EPILOG1()

  1077 	asm("trealxfromint0:");

  1078 	asm("mov [ecx], edx");

  1079 	asm("mov [ecx+4], edx");			// store mantissa high word=0

  1080 	asm("mov [ecx+8], edx");			// store sign/exponent=0

  1081 	asm("mov eax, ecx");				// return eax=this

  1082 	THISCALL_EPILOG1()

  1083 	}

  1084 

  1085 

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

  1087 /**

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

  1089 

  1090 @param aInt The signed integer value.

  1091 */

  1092 	{

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

  1094 	asm("jmp %a0": : "i"(&__6TRealXi));

  1095 	}

  1096 

  1097 

  1098 

  1099 

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

  1101 /**

  1102 Assigns the specified signed integer value to this extended precision object.

  1103 

  1104 @param aInt The signed integer value.

  1105 

  1106 @return A reference to this extended precision object.

  1107 */

  1108 	{

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

  1110 	asm("jmp %a0": : "i"(&__6TRealXi));

  1111 	}

  1112 

  1113 

  1114 

  1115 LOCAL_C __NAKED__ void __6TRealXui()

  1116 	{

  1117 	// common function for unsigned int to TRealX

  1118 	THISCALL_PROLOG1()

  1119 	asm("mov edx, [esp+4]");			// edx=aInt

  1120 	asm("mov eax, 0x7FFF");

  1121 	asm("or edx, edx");					// test for zero

  1122 	asm("jz short trealxfromuint0");	// branch if 0

  1123 	asm("push ecx");					// save this

  1124 	asm("bsr ecx, edx");				// bit number of edx MSB into ecx

  1125 	asm("add eax, ecx");				// add to eax to form result exponent

  1126 	asm("neg cl");

  1127 	asm("add cl, 31");					// 31-bit number = number of shifts to normalise edx

  1128 	asm("shl edx, cl");					// normalise edx

  1129 	asm("pop ecx");						// this back into ecx

  1130 	asm("shl eax, 16");					// exponent into normal position

  1131 	asm("mov [ecx+4], edx");			// store mantissa high word

  1132 	asm("mov [ecx+8], eax");			// store exponent

  1133 	asm("xor eax, eax");

  1134 	asm("mov [ecx], eax");				// zero mantissa low word