LXR 6.1/​bsps/​m68k/​shared/​fpsp/​decbin.S	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:23:48

 #include "fpsp-namespace.h"
 //
 //
 //  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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team