Subversion Repositories or1k

|

|       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

|

|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA

|       The copyright notice above does not evidence any

|       actual or intended publication of such source code.

|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

        beqs    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

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

        bras    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