diff options
Diffstat (limited to 'ANDROID_3.4.5/arch/m68k/fpsp040/decbin.S')
| -rw-r--r-- | ANDROID_3.4.5/arch/m68k/fpsp040/decbin.S | 505 |
1 files changed, 0 insertions, 505 deletions
diff --git a/ANDROID_3.4.5/arch/m68k/fpsp040/decbin.S b/ANDROID_3.4.5/arch/m68k/fpsp040/decbin.S deleted file mode 100644 index 16ed796b..00000000 --- a/ANDROID_3.4.5/arch/m68k/fpsp040/decbin.S +++ /dev/null @@ -1,505 +0,0 @@ -| -| decbin.sa 3.3 12/19/90 -| -| Description: Converts normalized packed bcd value pointed to by -| register A6 to extended-precision value in FP0. -| -| Input: Normalized packed bcd value in ETEMP(a6). -| -| Output: Exact floating-point representation of the packed bcd value. -| -| Saves and Modifies: D2-D5 -| -| Speed: The program decbin takes ??? cycles to execute. -| -| Object Size: -| -| External Reference(s): None. -| -| Algorithm: -| Expected is a normal bcd (i.e. non-exceptional; all inf, zero, -| and NaN operands are dispatched without entering this routine) -| value in 68881/882 format at location ETEMP(A6). -| -| A1. Convert the bcd exponent to binary by successive adds and muls. -| Set the sign according to SE. Subtract 16 to compensate -| for the mantissa which is to be interpreted as 17 integer -| digits, rather than 1 integer and 16 fraction digits. -| Note: this operation can never overflow. -| -| A2. Convert the bcd mantissa to binary by successive -| adds and muls in FP0. Set the sign according to SM. -| The mantissa digits will be converted with the decimal point -| assumed following the least-significant digit. -| Note: this operation can never overflow. -| -| A3. Count the number of leading/trailing zeros in the -| bcd string. If SE is positive, count the leading zeros; -| if negative, count the trailing zeros. Set the adjusted -| exponent equal to the exponent from A1 and the zero count -| added if SM = 1 and subtracted if SM = 0. Scale the -| mantissa the equivalent of forcing in the bcd value: -| -| SM = 0 a non-zero digit in the integer position -| SM = 1 a non-zero digit in Mant0, lsd of the fraction -| -| this will insure that any value, regardless of its -| representation (ex. 0.1E2, 1E1, 10E0, 100E-1), is converted -| consistently. -| -| A4. Calculate the factor 10^exp in FP1 using a table of -| 10^(2^n) values. To reduce the error in forming factors -| greater than 10^27, a directed rounding scheme is used with -| tables rounded to RN, RM, and RP, according to the table -| in the comments of the pwrten section. -| -| A5. Form the final binary number by scaling the mantissa by -| the exponent factor. This is done by multiplying the -| mantissa in FP0 by the factor in FP1 if the adjusted -| exponent sign is positive, and dividing FP0 by FP1 if -| it is negative. -| -| Clean up and return. Check if the final mul or div resulted -| in an inex2 exception. If so, set inex1 in the fpsr and -| check if the inex1 exception is enabled. If so, set d7 upper -| word to $0100. This will signal unimp.sa that an enabled inex1 -| exception occurred. Unimp will fix the stack. -| - -| Copyright (C) Motorola, Inc. 1990 -| All Rights Reserved -| -| For details on the license for this file, please see the -| file, README, in this same directory. - -|DECBIN idnt 2,1 | Motorola 040 Floating Point Software Package - - |section 8 - -#include "fpsp.h" - -| -| PTENRN, PTENRM, and PTENRP are arrays of powers of 10 rounded -| to nearest, minus, and plus, respectively. The tables include -| 10**{1,2,4,8,16,32,64,128,256,512,1024,2048,4096}. No rounding -| is required until the power is greater than 27, however, all -| tables include the first 5 for ease of indexing. -| - |xref PTENRN - |xref PTENRM - |xref PTENRP - -RTABLE: .byte 0,0,0,0 - .byte 2,3,2,3 - .byte 2,3,3,2 - .byte 3,2,2,3 - - .global decbin - .global calc_e - .global pwrten - .global calc_m - .global norm - .global ap_st_z - .global ap_st_n -| - .set FNIBS,7 - .set FSTRT,0 -| - .set ESTRT,4 - .set EDIGITS,2 | -| -| Constants in single precision -FZERO: .long 0x00000000 -FONE: .long 0x3F800000 -FTEN: .long 0x41200000 - - .set TEN,10 - -| -decbin: - | fmovel #0,FPCR ;clr real fpcr - moveml %d2-%d5,-(%a7) -| -| Calculate exponent: -| 1. Copy bcd value in memory for use as a working copy. -| 2. Calculate absolute value of exponent in d1 by mul and add. -| 3. Correct for exponent sign. -| 4. Subtract 16 to compensate for interpreting the mant as all integer digits. -| (i.e., all digits assumed left of the decimal point.) -| -| Register usage: -| -| calc_e: -| (*) d0: temp digit storage -| (*) d1: accumulator for binary exponent -| (*) d2: digit count -| (*) d3: offset pointer -| ( ) d4: first word of bcd -| ( ) a0: pointer to working bcd value -| ( ) a6: pointer to original bcd value -| (*) FP_SCR1: working copy of original bcd value -| (*) L_SCR1: copy of original exponent word -| -calc_e: - movel #EDIGITS,%d2 |# of nibbles (digits) in fraction part - moveql #ESTRT,%d3 |counter to pick up digits - leal FP_SCR1(%a6),%a0 |load tmp bcd storage address - movel ETEMP(%a6),(%a0) |save input bcd value - movel ETEMP_HI(%a6),4(%a0) |save words 2 and 3 - movel ETEMP_LO(%a6),8(%a0) |and work with these - movel (%a0),%d4 |get first word of bcd - clrl %d1 |zero d1 for accumulator -e_gd: - mulul #TEN,%d1 |mul partial product by one digit place - bfextu %d4{%d3:#4},%d0 |get the digit and zero extend into d0 - addl %d0,%d1 |d1 = d1 + d0 - addqb #4,%d3 |advance d3 to the next digit - dbf %d2,e_gd |if we have used all 3 digits, exit loop - btst #30,%d4 |get SE - beqs e_pos |don't negate if pos - negl %d1 |negate before subtracting -e_pos: - subl #16,%d1 |sub to compensate for shift of mant - bges e_save |if still pos, do not neg - negl %d1 |now negative, make pos and set SE - orl #0x40000000,%d4 |set SE in d4, - orl #0x40000000,(%a0) |and in working bcd -e_save: - movel %d1,L_SCR1(%a6) |save exp in memory -| -| -| Calculate mantissa: -| 1. Calculate absolute value of mantissa in fp0 by mul and add. -| 2. Correct for mantissa sign. -| (i.e., all digits assumed left of the decimal point.) -| -| Register usage: -| -| calc_m: -| (*) d0: temp digit storage -| (*) d1: lword counter -| (*) d2: digit count -| (*) d3: offset pointer -| ( ) d4: words 2 and 3 of bcd -| ( ) a0: pointer to working bcd value -| ( ) a6: pointer to original bcd value -| (*) fp0: mantissa accumulator -| ( ) FP_SCR1: working copy of original bcd value -| ( ) L_SCR1: copy of original exponent word -| -calc_m: - moveql #1,%d1 |word counter, init to 1 - fmoves FZERO,%fp0 |accumulator -| -| -| Since the packed number has a long word between the first & second parts, -| get the integer digit then skip down & get the rest of the -| mantissa. We will unroll the loop once. -| - bfextu (%a0){#28:#4},%d0 |integer part is ls digit in long word - faddb %d0,%fp0 |add digit to sum in fp0 -| -| -| Get the rest of the mantissa. -| -loadlw: - movel (%a0,%d1.L*4),%d4 |load mantissa longword into d4 - moveql #FSTRT,%d3 |counter to pick up digits - moveql #FNIBS,%d2 |reset number of digits per a0 ptr -md2b: - fmuls FTEN,%fp0 |fp0 = fp0 * 10 - bfextu %d4{%d3:#4},%d0 |get the digit and zero extend - faddb %d0,%fp0 |fp0 = fp0 + digit -| -| -| If all the digits (8) in that long word have been converted (d2=0), -| then inc d1 (=2) to point to the next long word and reset d3 to 0 -| to initialize the digit offset, and set d2 to 7 for the digit count; -| else continue with this long word. -| - addqb #4,%d3 |advance d3 to the next digit - dbf %d2,md2b |check for last digit in this lw -nextlw: - addql #1,%d1 |inc lw pointer in mantissa - cmpl #2,%d1 |test for last lw - ble loadlw |if not, get last one - -| -| Check the sign of the mant and make the value in fp0 the same sign. -| -m_sign: - btst #31,(%a0) |test sign of the mantissa - beq ap_st_z |if clear, go to append/strip zeros - fnegx %fp0 |if set, negate fp0 - -| -| Append/strip zeros: -| -| For adjusted exponents which have an absolute value greater than 27*, -| this routine calculates the amount needed to normalize the mantissa -| for the adjusted exponent. That number is subtracted from the exp -| if the exp was positive, and added if it was negative. The purpose -| of this is to reduce the value of the exponent and the possibility -| of error in calculation of pwrten. -| -| 1. Branch on the sign of the adjusted exponent. -| 2p.(positive exp) -| 2. Check M16 and the digits in lwords 2 and 3 in descending order. -| 3. Add one for each zero encountered until a non-zero digit. -| 4. Subtract the count from the exp. -| 5. Check if the exp has crossed zero in #3 above; make the exp abs -| and set SE. -| 6. Multiply the mantissa by 10**count. -| 2n.(negative exp) -| 2. Check the digits in lwords 3 and 2 in descending order. -| 3. Add one for each zero encountered until a non-zero digit. -| 4. Add the count to the exp. -| 5. Check if the exp has crossed zero in #3 above; clear SE. -| 6. Divide the mantissa by 10**count. -| -| *Why 27? If the adjusted exponent is within -28 < expA < 28, than -| any adjustment due to append/strip zeros will drive the resultant -| exponent towards zero. Since all pwrten constants with a power -| of 27 or less are exact, there is no need to use this routine to -| attempt to lessen the resultant exponent. -| -| Register usage: -| -| ap_st_z: -| (*) d0: temp digit storage -| (*) d1: zero count -| (*) d2: digit count -| (*) d3: offset pointer -| ( ) d4: first word of bcd -| (*) d5: lword counter -| ( ) a0: pointer to working bcd value -| ( ) FP_SCR1: working copy of original bcd value -| ( ) L_SCR1: copy of original exponent word -| -| -| First check the absolute value of the exponent to see if this -| routine is necessary. If so, then check the sign of the exponent -| and do append (+) or strip (-) zeros accordingly. -| This section handles a positive adjusted exponent. -| -ap_st_z: - movel L_SCR1(%a6),%d1 |load expA for range test - cmpl #27,%d1 |test is with 27 - ble pwrten |if abs(expA) <28, skip ap/st zeros - btst #30,(%a0) |check sign of exp - bne ap_st_n |if neg, go to neg side - clrl %d1 |zero count reg - movel (%a0),%d4 |load lword 1 to d4 - bfextu %d4{#28:#4},%d0 |get M16 in d0 - bnes ap_p_fx |if M16 is non-zero, go fix exp - addql #1,%d1 |inc zero count - moveql #1,%d5 |init lword counter - movel (%a0,%d5.L*4),%d4 |get lword 2 to d4 - bnes ap_p_cl |if lw 2 is zero, skip it - addql #8,%d1 |and inc count by 8 - addql #1,%d5 |inc lword counter - movel (%a0,%d5.L*4),%d4 |get lword 3 to d4 -ap_p_cl: - clrl %d3 |init offset reg - moveql #7,%d2 |init digit counter -ap_p_gd: - bfextu %d4{%d3:#4},%d0 |get digit - bnes ap_p_fx |if non-zero, go to fix exp - addql #4,%d3 |point to next digit - addql #1,%d1 |inc digit counter - dbf %d2,ap_p_gd |get next digit -ap_p_fx: - movel %d1,%d0 |copy counter to d2 - movel L_SCR1(%a6),%d1 |get adjusted exp from memory - subl %d0,%d1 |subtract count from exp - bges ap_p_fm |if still pos, go to pwrten - negl %d1 |now its neg; get abs - movel (%a0),%d4 |load lword 1 to d4 - orl #0x40000000,%d4 | and set SE in d4 - orl #0x40000000,(%a0) | and in memory -| -| Calculate the mantissa multiplier to compensate for the striping of -| zeros from the mantissa. -| -ap_p_fm: - movel #PTENRN,%a1 |get address of power-of-ten table - clrl %d3 |init table index - fmoves FONE,%fp1 |init fp1 to 1 - moveql #3,%d2 |init d2 to count bits in counter -ap_p_el: - asrl #1,%d0 |shift lsb into carry - bccs ap_p_en |if 1, mul fp1 by pwrten factor - fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no) -ap_p_en: - addl #12,%d3 |inc d3 to next rtable entry - tstl %d0 |check if d0 is zero - bnes ap_p_el |if not, get next bit - fmulx %fp1,%fp0 |mul mantissa by 10**(no_bits_shifted) - bra pwrten |go calc pwrten -| -| This section handles a negative adjusted exponent. -| -ap_st_n: - clrl %d1 |clr counter - moveql #2,%d5 |set up d5 to point to lword 3 - movel (%a0,%d5.L*4),%d4 |get lword 3 - bnes ap_n_cl |if not zero, check digits - subl #1,%d5 |dec d5 to point to lword 2 - addql #8,%d1 |inc counter by 8 - movel (%a0,%d5.L*4),%d4 |get lword 2 -ap_n_cl: - movel #28,%d3 |point to last digit - moveql #7,%d2 |init digit counter -ap_n_gd: - bfextu %d4{%d3:#4},%d0 |get digit - bnes ap_n_fx |if non-zero, go to exp fix - subql #4,%d3 |point to previous digit - addql #1,%d1 |inc digit counter - dbf %d2,ap_n_gd |get next digit -ap_n_fx: - movel %d1,%d0 |copy counter to d0 - movel L_SCR1(%a6),%d1 |get adjusted exp from memory - subl %d0,%d1 |subtract count from exp - bgts ap_n_fm |if still pos, go fix mantissa - negl %d1 |take abs of exp and clr SE - movel (%a0),%d4 |load lword 1 to d4 - andl #0xbfffffff,%d4 | and clr SE in d4 - andl #0xbfffffff,(%a0) | and in memory -| -| Calculate the mantissa multiplier to compensate for the appending of -| zeros to the mantissa. -| -ap_n_fm: - movel #PTENRN,%a1 |get address of power-of-ten table - clrl %d3 |init table index - fmoves FONE,%fp1 |init fp1 to 1 - moveql #3,%d2 |init d2 to count bits in counter -ap_n_el: - asrl #1,%d0 |shift lsb into carry - bccs ap_n_en |if 1, mul fp1 by pwrten factor - fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no) -ap_n_en: - addl #12,%d3 |inc d3 to next rtable entry - tstl %d0 |check if d0 is zero - bnes ap_n_el |if not, get next bit - fdivx %fp1,%fp0 |div mantissa by 10**(no_bits_shifted) -| -| -| Calculate power-of-ten factor from adjusted and shifted exponent. -| -| Register usage: -| -| pwrten: -| (*) d0: temp -| ( ) d1: exponent -| (*) d2: {FPCR[6:5],SM,SE} as index in RTABLE; temp -| (*) d3: FPCR work copy -| ( ) d4: first word of bcd -| (*) a1: RTABLE pointer -| calc_p: -| (*) d0: temp -| ( ) d1: exponent -| (*) d3: PWRTxx table index -| ( ) a0: pointer to working copy of bcd -| (*) a1: PWRTxx pointer -| (*) fp1: power-of-ten accumulator -| -| Pwrten calculates the exponent factor in the selected rounding mode -| according to the following table: -| -| Sign of Mant Sign of Exp Rounding Mode PWRTEN Rounding Mode -| -| ANY ANY RN RN -| -| + + RP RP -| - + RP RM -| + - RP RM -| - - RP RP -| -| + + RM RM -| - + RM RP -| + - RM RP -| - - RM RM -| -| + + RZ RM -| - + RZ RM -| + - RZ RP -| - - RZ RP -| -| -pwrten: - movel USER_FPCR(%a6),%d3 |get user's FPCR - bfextu %d3{#26:#2},%d2 |isolate rounding mode bits - movel (%a0),%d4 |reload 1st bcd word to d4 - asll #2,%d2 |format d2 to be - bfextu %d4{#0:#2},%d0 | {FPCR[6],FPCR[5],SM,SE} - addl %d0,%d2 |in d2 as index into RTABLE - leal RTABLE,%a1 |load rtable base - moveb (%a1,%d2),%d0 |load new rounding bits from table - clrl %d3 |clear d3 to force no exc and extended - bfins %d0,%d3{#26:#2} |stuff new rounding bits in FPCR - fmovel %d3,%FPCR |write new FPCR - asrl #1,%d0 |write correct PTENxx table - bccs not_rp |to a1 - leal PTENRP,%a1 |it is RP - bras calc_p |go to init section -not_rp: - asrl #1,%d0 |keep checking - bccs not_rm - leal PTENRM,%a1 |it is RM - bras calc_p |go to init section -not_rm: - leal PTENRN,%a1 |it is RN -calc_p: - movel %d1,%d0 |copy exp to d0;use d0 - bpls no_neg |if exp is negative, - negl %d0 |invert it - orl #0x40000000,(%a0) |and set SE bit -no_neg: - clrl %d3 |table index - fmoves FONE,%fp1 |init fp1 to 1 -e_loop: - asrl #1,%d0 |shift next bit into carry - bccs e_next |if zero, skip the mul - fmulx (%a1,%d3),%fp1 |mul by 10**(d3_bit_no) -e_next: - addl #12,%d3 |inc d3 to next rtable entry - tstl %d0 |check if d0 is zero - bnes e_loop |not zero, continue shifting -| -| -| Check the sign of the adjusted exp and make the value in fp0 the -| same sign. If the exp was pos then multiply fp1*fp0; -| else divide fp0/fp1. -| -| Register Usage: -| norm: -| ( ) a0: pointer to working bcd value -| (*) fp0: mantissa accumulator -| ( ) fp1: scaling factor - 10**(abs(exp)) -| -norm: - btst #30,(%a0) |test the sign of the exponent - beqs mul |if clear, go to multiply -div: - fdivx %fp1,%fp0 |exp is negative, so divide mant by exp - bras end_dec -mul: - fmulx %fp1,%fp0 |exp is positive, so multiply by exp -| -| -| Clean up and return with result in fp0. -| -| If the final mul/div in decbin incurred an inex exception, -| it will be inex2, but will be reported as inex1 by get_op. -| -end_dec: - fmovel %FPSR,%d0 |get status register - bclrl #inex2_bit+8,%d0 |test for inex2 and clear it - fmovel %d0,%FPSR |return status reg w/o inex2 - beqs no_exc |skip this if no exc - orl #inx1a_mask,USER_FPSR(%a6) |set inex1/ainex -no_exc: - moveml (%a7)+,%d2-%d5 - rts - |end |