subttl emlsbcd.asm - FBSTP and FBLD instructions page ;emlsbcd.asm - FBSTP and FBLD instructions ; Microsoft Confidential ; Copyright (c) Microsoft Corporation 1991 ; All Rights Reserved ;Purpose: ; FBSTP and FBLD instructions. ; These routines convert between 64-bit integer and 18-digit packed BCD ; format. They work by splitting the number being converted in half ; and converting the two halves separately. This works well because ; 9 decimal digits fit nicely within 30 binary bits, so converion of ; each half is strictly a 32-bit operation. ;Inputs: ; edi = [CURstk] ; dseg:esi = pointer to memory operand ;Revision History: ; [] 09/05/91 TP Initial 32-bit version. eFBLD: mov eax,dseg:[esi+5] ;Get high 8 digits or eax,eax ;Anything there? jz HighDigitsZero mov ecx,8 call ReadDigits ;Convert first 8 digits to binary mov eax,dseg:[esi+1] ;Get next 8 digits xor edi,edi shld edi,eax,4 ;Shift ninth digit into edi imul ebx,10 add edi,ebx ;Accumulate ninth digit SecondNineDigits: xor ebx,ebx ;In case eax==0 shl eax,4 ;Keep digits left justified jz LastTwoDigits mov ecx,7 call ReadDigits ;Convert next 7 digits to binary LastTwoDigits: mov al,dseg:[esi] ;Get last two digits shl eax,24 ;Left justify mov ecx,2 call InDigitLoop ;Accumulate last two digits ;edi = binary value of high 9 digits ;ebx = binary value of low 9 digits mov eax,1000000000 ;One billion: shift nine digits left mul edi ;Left shift 9 digits. 9 cl. if edi==0 add ebx,eax ;Add in low digits adc edx,0 BcdReadyToNorm: ;edx:ebx = integer converted to binary mov eax,dseg:[esi+6] ;Get sign to high bit of eax mov esi,ebx mov ebx,edx mov edi,EMSEG:[CURstk] ;mantissa in ebx:esi, sign in high bit of eax ;edi = [CURstk] jmp NormQuadInt ;in emload.asm HighDigitsZero: mov eax,dseg:[esi+1] ;Get next 8 digits or eax,eax ;Anything there? jz CheckLastTwo xor edi,edi shld edi,eax,4 ;Shift ninth digit into edi jmp SecondNineDigits CheckLastTwo: mov bl,dseg:[esi] ;Get last two digits or bl,bl jz ZeroBCD mov al,bl shr al,4 ;Bring down upper digit imul eax,10 and ebx,0FH ;Keep lowest digit only add ebx,eax xor edx,edx jmp BcdReadyToNorm ZeroBCD: mov ecx,bTAG_ZERO ;Exponent is zero mov ch,dseg:[esi+9] ;Get sign byte to ch xor ebx,ebx mov esi,ebx ;mantissa in ebx:esi, exp/sign in ecx ;edi = [CURstk] jmp FldCont ;in emload.asm ;*** ReadDigits ;Inputs: ; eax = packed BCD digits, left justified, non-zero ; ecx = no. of digits, 7 or 8 ;Outputs: ; ebx = number SkipZeroDigits: sub ecx,3 shl eax,12 ReadDigits: ;We start by scanning off leading zeros. This costs 16 cl./nybble in ;the ScanZero loop. To reduce this cost for many leading zeros, we ;check for three leading zeros at a time. Adding this test saves ;26 cl. for 3 leading zeros, 57 cl. for 6 leading zeros, at a cost ;of only 5 cl. if less than 3 zeros. We choose 3 at a time so we ;can repeat it once (there are never more than 7 zeros). test eax,0FFF00000H ;Check first 3 nybbles for zero jz SkipZeroDigits xor ebx,ebx ScanZero: ;Note that bsr is 3 cl/bit, or 12 cl/nybble. Add in the overhead and ;this loop of 16 cl/nybble is cheaper for the 1 - 3 digits it does. dec ecx shld ebx,eax,4 ;Shift digit into ebx rol eax,4 ;Left justify **Doesn't affect ZF!** jz ScanZero ;Skip to next digit if zero jecxz ReadDigitsX InDigitLoop: ;eax = digits to convert, left justified ;ebx = result accumulation ;ecx = number of digits to convert xor edx,edx shld edx,eax,4 ;Shift digit into edx shl eax,4 ;Keep digits left justified imul ebx,10 ;Only 10 clocks on 386! add ebx,edx ;Accumulate number dec ecx jnz InDigitLoop ReadDigitsX: ret ChkInvalidBCD: ja SetInvalidBCD cmp edi,0A7640000H ;(1000000000*1000000000) and 0ffffffffh jb ValidBCD SetInvalidBCD: mov EMSEG:[CURerr],Invalid InvalidBCD: test EMSEG:[CWmask],Invalid ;Is it masked? jz ReadDigitsX ;No--leave memory unchanged ;Store Indefinite mov dword ptr dseg:[esi],0 mov dword ptr dseg:[esi+4],0 mov word ptr dseg:[esi+8],-1 ;0FF00000000H for packed BCD indefinite jmp PopStack ;in emstore.asm eFBSTP: call RoundToInteger ;Get integer in ebx:edi, sign in ch jc InvalidBCD cmp ebx,0DE0B6B3H ;(1000000000*1000000000) shr 32 jae ChkInvalidBCD ValidBCD: and ch,bSign mov dseg:[esi+9],ch ;Fill in sign byte mov edx,ebx mov eax,edi ;Get number to edx:eax for division mov ebx,1000000000 div ebx ;Break into two 9-digit halves xor ecx,ecx ;Initial digits mov edi,eax ;Save quotient mov eax,edx or eax,eax jz SaveLowBCD call WriteDigits shrd ecx,eax,4 ;Pack 8th digit xor al,al shl eax,20 ;Move digit in ah to high end SaveLowBCD: mov dseg:[esi],ecx ;Save low 8 digits mov ecx,eax ;Get ready for next 8 digits mov eax,edi or eax,eax jz ZeroHighBCD call WriteDigits shl ah,4 ;Move digit to upper nybble or al,ah ;Combine last two digits SaveHighBCD: mov dseg:[esi+4],ecx ;Save lower 8 digits mov dseg:[esi+8],al jmp PopStack ZeroHighBCD: shr ecx,28 ;Position 9th digit jmp SaveHighBCD ;*** WriteDigits ;Inputs: ; eax = binary number < 1,000,000,000 and > 0 ; ecx = Zero or had one BCD digit left justified ;Purpose: ; Convert binary integer to BCD. ; The time required for the DIV instruction is dependent on operand ; size, at 6 + (no. of bits) clocks for 386. (In contrast, multiply ; by 10 as used in FBLD/ReadDigits above takes the same amount of ; time regardless of operand size--only 10 clocks.) ; The easy way to do this conversion would be to repeatedly do a ; 32-bit division by 10 (at 38 clocks/divide). Instead, the number ; is broken down so that mostly 8-bit division is used (only 14 clocks). ; AAM (17 clocks) is also used to save us from having to load the ; constant 10 and zero ah. AAM is faster than DIV on the 486sx. ;Outputs: ; ecx has seven more digits packed into it (from left) ; ah:al = most significant two digits (unpacked) ;esi,edi preserved WriteDigits: ;eax = binary number < 1,000,000,000 cdq ;Zero edx mov ebx,10000 div ebx ;Break into 4-digit and 5-digit pieces mov bl,100 or edx,edx jz ZeroLowDigits xchg edx,eax ;Get 4-digit remainder to eax ;Compute low 4 digits ; 0 < eax < 10000 div bl ;Get two 2-digit pieces. 14cl on 386 mov bh,al ;Save high 2 digits mov al,ah ;Get low digits aam shl ah,4 ;Move digit to upper nybble or al,ah shrd ecx,eax,8 mov al,bh ;Get high 2 digits aam shl ah,4 ;Move digit to upper nybble or al,ah shrd ecx,eax,8 ;Compute high 5 digits mov eax,edx ;5-digit quotient to eax or eax,eax jz ZeroHighDigits ConvHigh5: cdq ;Zero edx shld edx,eax,16 ;Put quotient in dx:ax xor bh,bh ;bx = 100 div bx ;Get 2- and 3-digit pieces. 22cl on 386 xchg edx,eax ;Save high 3 digits, get log 2 digits aam shl ah,4 ;Move digit to upper nybble or al,ah shrd ecx,eax,8 mov eax,edx ;Get high 3 digits mov bl,10 div bl mov bl,ah ;Remainder is next digit shrd ecx,ebx,4 aam ;Get last two digits ;Last two digits in ah:al ret ZeroLowDigits: shr ecx,16 jmp ConvHigh5 ZeroHighDigits: shr ecx,12 ret