Subversion Repositories or1k

//

//      $Id: decbin.S,v 1.2 2001-09-27 12:01:22 chris Exp $

//

//      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.defs"

//

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