Quelle  decbin.S   Sprache: Sparc

|
| 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