source: rtems/c/src/lib/libcpu/m68k/m68040/fpsp/decbin.S @ 9b4422a2

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