forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
505 lines
15 KiB
505 lines
15 KiB
| |
|
| 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
|
|
|