Quelle  bindec.S   Sprache: Sparc

|
| bindec.sa 3.4 1/3/91
|
| bindec
|
| Description:
|  Converts an input in extended precision format
|  to bcd format.
|
| Input:
|  a0 points to the input extended precision value
|  value in memory; d0 contains the k-factor sign-extended
|  to 32-bits.  The input may be either normalized,
|  unnormalized, or denormalized.
|
| Output: result in the FP_SCR1 space on the stack.
|
| Saves and Modifies: D2-D7,A2,FP2
|
| Algorithm:
|
| A1. Set RM and size ext;  Set SIGMA = sign of input.
|  The k-factor is saved for use in d7. Clear the
|  BINDEC_FLG for separating normalized/denormalized
|  input.  If input is unnormalized or denormalized,
|  normalize it.
|
| A2. Set X = abs(input).
|
| A3. Compute ILOG.
|  ILOG is the log base 10 of the input value.  It is
|  approximated by adding e + 0.f when the original
|  value is viewed as 2^^e * 1.f in extended precision.
|  This value is stored in d6.
|
| A4. Clr INEX bit.
|  The operation in A3 above may have set INEX2.
|
| A5. Set ICTR = 0;
|  ICTR is a flag used in A13.  It must be set before the
|  loop entry A6.
|
| A6. Calculate LEN.
|  LEN is the number of digits to be displayed.  The
|  k-factor can dictate either the total number of digits,
|  if it is a positive number, or the number of digits
|  after the decimal point which are to be included as
|  significant.  See the 68882 manual for examples.
|  If LEN is computed to be greater than 17, set OPERR in
|  USER_FPSR.  LEN is stored in d4.
|
| A7. Calculate SCALE.
|  SCALE is equal to 10^ISCALE, where ISCALE is the number
|  of decimal places needed to insure LEN integer digits
|  in the output before conversion to bcd. LAMBDA is the
|  sign of ISCALE, used in A9. Fp1 contains
|  10^^(abs(ISCALE)) using a rounding mode which is a
|  function of the original rounding mode and the signs
|  of ISCALE and X.  A table is given in the code.
|
| A8. Clr INEX; Force RZ.
|  The operation in A3 above may have set INEX2.
|  RZ mode is forced for the scaling operation to insure
|  only one rounding error.  The grs bits are collected in
|  the INEX flag for use in A10.
|
| A9. Scale X -> Y.
|  The mantissa is scaled to the desired number of
|  significant digits.  The excess digits are collected
|  in INEX2.
|
| A10. Or in INEX.
|  If INEX is set, round error occurred.  This is
|  compensated for by 'or-ing' in the INEX2 flag to
|  the lsb of Y.
|
| A11. Restore original FPCR; set size ext.
|  Perform FINT operation in the user's rounding mode.
|  Keep the size to extended.
|
| A12. Calculate YINT = FINT(Y) according to user's rounding
|  mode.  The FPSP routine sintd0 is used.  The output
|  is in fp0.
|
| A13. Check for LEN digits.
|  If the int operation results in more than LEN digits,
|  or less than LEN -1 digits, adjust ILOG and repeat from
|  A6.  This test occurs only on the first pass.  If the
|  result is exactly 10^LEN, decrement ILOG and divide
|  the mantissa by 10.
|
| A14. Convert the mantissa to bcd.
|  The binstr routine is used to convert the LEN digit
|  mantissa to bcd in memory.  The input to binstr is
|  to be a fraction; i.e. (mantissa)/10^LEN and adjusted
|  such that the decimal point is to the left of bit 63.
|  The bcd digits are stored in the correct position in
|  the final string area in memory.
|
| A15. Convert the exponent to bcd.
|  As in A14 above, the exp is converted to bcd and the
|  digits are stored in the final string.
|  Test the length of the final exponent string.  If the
|  length is 4, set operr.
|
| A16. Write sign bits to final string.
|
| Implementation Notes:
|
| The registers are used as follows:
|
|  d0: scratch; LEN input to binstr
|  d1: scratch
|  d2: upper 32-bits of mantissa for binstr
|  d3: scratch;lower 32-bits of mantissa for binstr
|  d4: LEN
|  d5: LAMBDA/ICTR
|  d6: ILOG
|  d7: k-factor
|  a0: ptr for original operand/final result
|  a1: scratch pointer
|  a2: pointer to FP_X; abs(original value) in ext
|  fp0: scratch
|  fp1: scratch
|  fp2: scratch
|  F_SCR1:
|  F_SCR2:
|  L_SCR1:
|  L_SCR2:

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

|BINDEC    idnt    2,1 | Motorola 040 Floating Point Software Package

#include "fpsp.h"

 |section 8

| Constants in extended precision
LOG2: .long 0x3FFD0000,0x9A209A84,0xFBCFF798,0x00000000
LOG2UP1: .long 0x3FFD0000,0x9A209A84,0xFBCFF799,0x00000000

| Constants in single precision
FONE: .long 0x3F800000,0x00000000,0x00000000,0x00000000
FTWO: .long 0x40000000,0x00000000,0x00000000,0x00000000
FTEN: .long 0x41200000,0x00000000,0x00000000,0x00000000
F4933: .long 0x459A2800,0x00000000,0x00000000,0x00000000

RBDTBL: .byte 0,0,0,0
 .byte 3,3,2,2
 .byte 3,2,2,3
 .byte 2,3,3,2

 |xref binstr
 |xref sintdo
 |xref ptenrn,ptenrm,ptenrp

 .global bindec
 .global sc_mul
bindec:
 moveml %d2-%d7/%a2,-(%a7)
 fmovemx %fp0-%fp2,-(%a7)

| A1. Set RM and size ext. Set SIGMA = sign input;
|     The k-factor is saved for use in d7.  Clear BINDEC_FLG for
|     separating  normalized/denormalized input.  If the input
|     is a denormalized number, set the BINDEC_FLG memory word
|     to signal denorm.  If the input is unnormalized, normalize
|     the input and test for denormalized result.
|
 fmovel #rm_mode,%FPCR |set RM and ext
 movel (%a0),L_SCR2(%a6) |save exponent for sign check
 movel %d0,%d7  |move k-factor to d7
 clrb BINDEC_FLG(%a6) |clr norm/denorm flag
 movew STAG(%a6),%d0 |get stag
 andiw #0xe000,%d0 |isolate stag bits
 beq A2_str  |if zero, input is norm
|
| Normalize the denorm
|
un_de_norm:
 movew (%a0),%d0
 andiw #0x7fff,%d0 |strip sign of normalized exp
 movel 4(%a0),%d1
 movel 8(%a0),%d2
norm_loop:
 subw #1,%d0
 lsll #1,%d2
 roxll #1,%d1
 tstl %d1
 bges norm_loop
|
| Test if the normalized input is denormalized
|
 tstw %d0
 bgts pos_exp  |if greater than zero, it is a norm
 st BINDEC_FLG(%a6) |set flag for denorm
pos_exp:
 andiw #0x7fff,%d0 |strip sign of normalized exp
 movew %d0,(%a0)
 movel %d1,4(%a0)
 movel %d2,8(%a0)

| A2. Set X = abs(input).
|
A2_str:
 movel (%a0),FP_SCR2(%a6) | move input to work space
 movel 4(%a0),FP_SCR2+4(%a6) | move input to work space
 movel 8(%a0),FP_SCR2+8(%a6) | move input to work space
 andil #0x7fffffff,FP_SCR2(%a6) |create abs(X)

| A3. Compute ILOG.
|     ILOG is the log base 10 of the input value.  It is approx-
|     imated by adding e + 0.f when the original value is viewed
|     as 2^^e * 1.f in extended precision.  This value is stored
|     in d6.
|
| Register usage:
| Input/Output
| d0: k-factor/exponent
| d2: x/x
| d3: x/x
| d4: x/x
| d5: x/x
| d6: x/ILOG
| d7: k-factor/Unchanged
| a0: ptr for original operand/final result
| a1: x/x
| a2: x/x
| fp0: x/float(ILOG)
| fp1: x/x
| fp2: x/x
| F_SCR1:x/x
| F_SCR2:Abs(X)/Abs(X) with $3fff exponent
| L_SCR1:x/x
| L_SCR2:first word of X packed/Unchanged

 tstb BINDEC_FLG(%a6) |check for denorm
 beqs A3_cont  |if clr, continue with norm
 movel #-4933,%d6 |force ILOG = -4933
 bras A4_str
A3_cont:
 movew FP_SCR2(%a6),%d0 |move exp to d0
 movew #0x3fff,FP_SCR2(%a6) |replace exponent with 0x3fff
 fmovex FP_SCR2(%a6),%fp0 |now fp0 has 1.f
 subw #0x3fff,%d0 |strip off bias
 faddw %d0,%fp0  |add in exp
 fsubs FONE,%fp0 |subtract off 1.0
 fbge pos_res  |if pos, branch
 fmulx LOG2UP1,%fp0 |if neg, mul by LOG2UP1
 fmovel %fp0,%d6  |put ILOG in d6 as a lword
 bras A4_str  |go move out ILOG
pos_res:
 fmulx LOG2,%fp0 |if pos, mul by LOG2
 fmovel %fp0,%d6  |put ILOG in d6 as a lword


| A4. Clr INEX bit.
|     The operation in A3 above may have set INEX2.

A4_str:
 fmovel #0,%FPSR  |zero all of fpsr - nothing needed


| A5. Set ICTR = 0;
|     ICTR is a flag used in A13.  It must be set before the
|     loop entry A6. The lower word of d5 is used for ICTR.

 clrw %d5  |clear ICTR


| A6. Calculate LEN.
|     LEN is the number of digits to be displayed.  The k-factor
|     can dictate either the total number of digits, if it is
|     a positive number, or the number of digits after the
|     original decimal point which are to be included as
|     significant.  See the 68882 manual for examples.
|     If LEN is computed to be greater than 17, set OPERR in
|     USER_FPSR.  LEN is stored in d4.
|
| Register usage:
| Input/Output
| d0: exponent/Unchanged
| d2: x/x/scratch
| d3: x/x
| d4: exc picture/LEN
| d5: ICTR/Unchanged
| d6: ILOG/Unchanged
| d7: k-factor/Unchanged
| a0: ptr for original operand/final result
| a1: x/x
| a2: x/x
| fp0: float(ILOG)/Unchanged
| fp1: x/x
| fp2: x/x
| F_SCR1:x/x
| F_SCR2:Abs(X) with $3fff exponent/Unchanged
| L_SCR1:x/x
| L_SCR2:first word of X packed/Unchanged

A6_str:
 tstl %d7  |branch on sign of k
 bles k_neg  |if k <= 0, LEN = ILOG + 1 - k
 movel %d7,%d4  |if k > 0, LEN = k
 bras len_ck  |skip to LEN check
k_neg:
 movel %d6,%d4  |first load ILOG to d4
 subl %d7,%d4  |subtract off k
 addql #1,%d4  |add in the 1
len_ck:
 tstl %d4  |LEN check: branch on sign of LEN
 bles LEN_ng  |if neg, set LEN = 1
 cmpl #17,%d4  |test if LEN > 17
 bles A7_str  |if not, forget it
 movel #17,%d4  |set max LEN = 17
 tstl %d7  |if negative, never set OPERR
 bles A7_str  |if positive, continue
 orl #opaop_mask,USER_FPSR(%a6) |set OPERR & AIOP in USER_FPSR
 bras A7_str  |finished here
LEN_ng:
 moveql #1,%d4  |min LEN is 1


| A7. Calculate SCALE.
|     SCALE is equal to 10^ISCALE, where ISCALE is the number
|     of decimal places needed to insure LEN integer digits
|     in the output before conversion to bcd. LAMBDA is the sign
|     of ISCALE, used in A9.  Fp1 contains 10^^(abs(ISCALE)) using
|     the rounding mode as given in the following table (see
|     Coonen, p. 7.23 as ref.; however, the SCALE variable is
|     of opposite sign in bindec.sa from Coonen).
|
| Initial     USE
| FPCR[6:5] LAMBDA SIGN(X)  FPCR[6:5]
| ----------------------------------------------
|  RN 00    0    0  00/0 RN
|  RN 00    0    1  00/0 RN
|  RN 00    1    0  00/0 RN
|  RN 00    1    1  00/0 RN
|  RZ 01    0    0  11/3 RP
|  RZ 01    0    1  11/3 RP
|  RZ 01    1    0  10/2 RM
|  RZ 01    1    1  10/2 RM
|  RM 10    0    0  11/3 RP
|  RM 10    0    1  10/2 RM
|  RM 10    1    0  10/2 RM
|  RM 10    1    1  11/3 RP
|  RP 11    0    0  10/2 RM
|  RP 11    0    1  11/3 RP
|  RP 11    1    0  11/3 RP
|  RP 11    1    1  10/2 RM
|
| Register usage:
| Input/Output
| d0: exponent/scratch - final is 0
| d2: x/0 or 24 for A9
| d3: x/scratch - offset ptr into PTENRM array
| d4: LEN/Unchanged
| d5: 0/ICTR:LAMBDA
| d6: ILOG/ILOG or k if ((k<=0)&(ILOG<k))
| d7: k-factor/Unchanged
| a0: ptr for original operand/final result
| a1: x/ptr to PTENRM array
| a2: x/x
| fp0: float(ILOG)/Unchanged
| fp1: x/10^ISCALE
| fp2: x/x
| F_SCR1:x/x
| F_SCR2:Abs(X) with $3fff exponent/Unchanged
| L_SCR1:x/x
| L_SCR2:first word of X packed/Unchanged

A7_str:
 tstl %d7  |test sign of k
 bgts k_pos  |if pos and > 0, skip this
 cmpl %d6,%d7  |test k - ILOG
 blts k_pos  |if ILOG >= k, skip this
 movel %d7,%d6  |if ((k<0) & (ILOG < k)) ILOG = k
k_pos:
 movel %d6,%d0  |calc ILOG + 1 - LEN in d0
 addql #1,%d0  |add the 1
 subl %d4,%d0  |sub off LEN
 swap %d5  |use upper word of d5 for LAMBDA
 clrw %d5  |set it zero initially
 clrw %d2  |set up d2 for very small case
 tstl %d0  |test sign of ISCALE
 bges iscale  |if pos, skip next inst
 addqw #1,%d5  |if neg, set LAMBDA true
 cmpl #0xffffecd4,%d0 |test iscale <= -4908
 bgts no_inf  |if false, skip rest
 addil #24,%d0  |add in 24 to iscale
 movel #24,%d2  |put 24 in d2 for A9
no_inf:
 negl %d0  |and take abs of ISCALE
iscale:
 fmoves FONE,%fp1 |init fp1 to 1
 bfextu USER_FPCR(%a6){#26:#2},%d1 |get initial rmode bits
 lslw #1,%d1  |put them in bits 2:1
 addw %d5,%d1  |add in LAMBDA
 lslw #1,%d1  |put them in bits 3:1
 tstl L_SCR2(%a6) |test sign of original x
 bges x_pos  |if pos, don't set bit 0
 addql #1,%d1  |if neg, set bit 0
x_pos:
 leal RBDTBL,%a2 |load rbdtbl base
 moveb (%a2,%d1),%d3 |load d3 with new rmode
 lsll #4,%d3  |put bits in proper position
 fmovel %d3,%fpcr  |load bits into fpu
 lsrl #4,%d3  |put bits in proper position
 tstb %d3  |decode new rmode for pten table
 bnes not_rn  |if zero, it is RN
 leal PTENRN,%a1 |load a1 with RN table base
 bras rmode  |exit decode
not_rn:
 lsrb #1,%d3  |get lsb in carry
 bccs not_rp  |if carry clear, it is RM
 leal PTENRP,%a1 |load a1 with RP table base
 bras rmode  |exit decode
not_rp:
 leal PTENRM,%a1 |load a1 with RM table base
rmode:
 clrl %d3  |clr table index
e_loop:
 lsrl #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 pwrten table entry
 tstl %d0  |test if ISCALE is zero
 bnes e_loop  |if not, loop


| A8. Clr INEX; Force RZ.
|     The operation in A3 above may have set INEX2.
|     RZ mode is forced for the scaling operation to insure
|     only one rounding error.  The grs bits are collected in
|     the INEX flag for use in A10.
|
| Register usage:
| Input/Output

 fmovel #0,%FPSR  |clr INEX
 fmovel #rz_mode,%FPCR |set RZ rounding mode


| A9. Scale X -> Y.
|     The mantissa is scaled to the desired number of significant
|     digits.  The excess digits are collected in INEX2. If mul,
|     Check d2 for excess 10 exponential value.  If not zero,
|     the iscale value would have caused the pwrten calculation
|     to overflow.  Only a negative iscale can cause this, so
|     multiply by 10^(d2), which is now only allowed to be 24,
|     with a multiply by 10^8 and 10^16, which is exact since
|     10^24 is exact.  If the input was denormalized, we must
|     create a busy stack frame with the mul command and the
|     two operands, and allow the fpu to complete the multiply.
|
| Register usage:
| Input/Output
| d0: FPCR with RZ mode/Unchanged
| d2: 0 or 24/unchanged
| d3: x/x
| d4: LEN/Unchanged
| d5: ICTR:LAMBDA
| d6: ILOG/Unchanged
| d7: k-factor/Unchanged
| a0: ptr for original operand/final result
| a1: ptr to PTENRM array/Unchanged
| a2: x/x
| fp0: float(ILOG)/X adjusted for SCALE (Y)
| fp1: 10^ISCALE/Unchanged
| fp2: x/x
| F_SCR1:x/x
| F_SCR2:Abs(X) with $3fff exponent/Unchanged
| L_SCR1:x/x
| L_SCR2:first word of X packed/Unchanged

A9_str:
 fmovex (%a0),%fp0 |load X from memory
 fabsx %fp0  |use abs(X)
 tstw %d5  |LAMBDA is in lower word of d5
 bne sc_mul  |if neg (LAMBDA = 1), scale by mul
 fdivx %fp1,%fp0  |calculate X / SCALE -> Y to fp0
 bras A10_st  |branch to A10

sc_mul:
 tstb BINDEC_FLG(%a6) |check for denorm
 beqs A9_norm  |if norm, continue with mul
 fmovemx %fp1-%fp1,-(%a7) |load ETEMP with 10^ISCALE
 movel 8(%a0),-(%a7) |load FPTEMP with input arg
 movel 4(%a0),-(%a7)
 movel (%a0),-(%a7)
 movel #18,%d3  |load count for busy stack
A9_loop:
 clrl -(%a7)  |clear lword on stack
 dbf %d3,A9_loop
 moveb VER_TMP(%a6),(%a7) |write current version number
 moveb #BUSY_SIZE-4,1(%a7) |write current busy size
 moveb #0x10,0x44(%a7) |set fcefpte[15] bit
 movew #0x0023,0x40(%a7) |load cmdreg1b with mul command
 moveb #0xfe,0x8(%a7) |load all 1s to cu savepc
 frestore (%a7)+  |restore frame to fpu for completion
 fmulx 36(%a1),%fp0 |multiply fp0 by 10^8
 fmulx 48(%a1),%fp0 |multiply fp0 by 10^16
 bras A10_st
A9_norm:
 tstw %d2  |test for small exp case
 beqs A9_con  |if zero, continue as normal
 fmulx 36(%a1),%fp0 |multiply fp0 by 10^8
 fmulx 48(%a1),%fp0 |multiply fp0 by 10^16
A9_con:
 fmulx %fp1,%fp0  |calculate X * SCALE -> Y to fp0


| A10. Or in INEX.
|      If INEX is set, round error occurred.  This is compensated
|      for by 'or-ing' in the INEX2 flag to the lsb of Y.
|
| Register usage:
| Input/Output
| d0: FPCR with RZ mode/FPSR with INEX2 isolated
| d2: x/x
| d3: x/x
| d4: LEN/Unchanged
| d5: ICTR:LAMBDA
| d6: ILOG/Unchanged
| d7: k-factor/Unchanged
| a0: ptr for original operand/final result
| a1: ptr to PTENxx array/Unchanged
| a2: x/ptr to FP_SCR2(a6)
| fp0: Y/Y with lsb adjusted
| fp1: 10^ISCALE/Unchanged
| fp2: x/x

A10_st:
 fmovel %FPSR,%d0  |get FPSR
 fmovex %fp0,FP_SCR2(%a6) |move Y to memory
 leal FP_SCR2(%a6),%a2 |load a2 with ptr to FP_SCR2
 btstl #9,%d0  |check if INEX2 set
 beqs A11_st  |if clear, skip rest
 oril #1,8(%a2) |or in 1 to lsb of mantissa
 fmovex FP_SCR2(%a6),%fp0 |write adjusted Y back to fpu


| A11. Restore original FPCR; set size ext.
|      Perform FINT operation in the user's rounding mode. Keep
|      the size to extended.  The sintdo entry point in the sint
|      routine expects the FPCR value to be in USER_FPCR for
|      mode and precision.  The original FPCR is saved in L_SCR1.

A11_st:
 movel USER_FPCR(%a6),L_SCR1(%a6) |save it for later
 andil #0x00000030,USER_FPCR(%a6) |set size to ext,
|     ;block exceptions


| A12. Calculate YINT = FINT(Y) according to user's rounding mode.
|      The FPSP routine sintd0 is used.  The output is in fp0.
|
| Register usage:
| Input/Output
| d0: FPSR with AINEX cleared/FPCR with size set to ext
| d2: x/x/scratch
| d3: x/x
| d4: LEN/Unchanged
| d5: ICTR:LAMBDA/Unchanged
| d6: ILOG/Unchanged
| d7: k-factor/Unchanged
| a0: ptr for original operand/src ptr for sintdo
| a1: ptr to PTENxx array/Unchanged
| a2: ptr to FP_SCR2(a6)/Unchanged
| a6: temp pointer to FP_SCR2(a6) - orig value saved and restored
| fp0: Y/YINT
| fp1: 10^ISCALE/Unchanged
| fp2: x/x
| F_SCR1:x/x
| F_SCR2:Y adjusted for inex/Y with original exponent
| L_SCR1:x/original USER_FPCR
| L_SCR2:first word of X packed/Unchanged

A12_st:
 moveml %d0-%d1/%a0-%a1,-(%a7) |save regs used by sintd0
 movel L_SCR1(%a6),-(%a7)
 movel L_SCR2(%a6),-(%a7)
 leal FP_SCR2(%a6),%a0  |a0 is ptr to F_SCR2(a6)
 fmovex %fp0,(%a0)  |move Y to memory at FP_SCR2(a6)
 tstl L_SCR2(%a6)  |test sign of original operand
 bges do_fint   |if pos, use Y
 orl #0x80000000,(%a0)  |if neg, use -Y
do_fint:
 movel USER_FPSR(%a6),-(%a7)
 bsr sintdo   |sint routine returns int in fp0
 moveb (%a7),USER_FPSR(%a6)
 addl #4,%a7
 movel (%a7)+,L_SCR2(%a6)
 movel (%a7)+,L_SCR1(%a6)
 moveml (%a7)+,%d0-%d1/%a0-%a1 |restore regs used by sint
 movel L_SCR2(%a6),FP_SCR2(%a6) |restore original exponent
 movel L_SCR1(%a6),USER_FPCR(%a6) |restore user's FPCR


| A13. Check for LEN digits.
|      If the int operation results in more than LEN digits,
|      or less than LEN -1 digits, adjust ILOG and repeat from
|      A6.  This test occurs only on the first pass.  If the
|      result is exactly 10^LEN, decrement ILOG and divide
|      the mantissa by 10.  The calculation of 10^LEN cannot
|      be inexact, since all powers of ten up to 10^27 are exact
|      in extended precision, so the use of a previous power-of-ten
|      table will introduce no error.
|
|
| Register usage:
| Input/Output
| d0: FPCR with size set to ext/scratch final = 0
| d2: x/x
| d3: x/scratch final = x
| d4: LEN/LEN adjusted
| d5: ICTR:LAMBDA/LAMBDA:ICTR
| d6: ILOG/ILOG adjusted
| d7: k-factor/Unchanged
| a0: pointer into memory for packed bcd string formation
| a1: ptr to PTENxx array/Unchanged
| a2: ptr to FP_SCR2(a6)/Unchanged
| fp0: int portion of Y/abs(YINT) adjusted
| fp1: 10^ISCALE/Unchanged
| fp2: x/10^LEN
| F_SCR1:x/x
| F_SCR2:Y with original exponent/Unchanged
| L_SCR1:original USER_FPCR/Unchanged
| L_SCR2:first word of X packed/Unchanged

A13_st:
 swap %d5  |put ICTR in lower word of d5
 tstw %d5  |check if ICTR = 0
 bne not_zr  |if non-zero, go to second test
|
| Compute 10^(LEN-1)
|
 fmoves FONE,%fp2 |init fp2 to 1.0
 movel %d4,%d0  |put LEN in d0
 subql #1,%d0  |d0 = LEN -1
 clrl %d3  |clr table index
l_loop:
 lsrl #1,%d0  |shift next bit into carry
 bccs l_next  |if zero, skip the mul
 fmulx (%a1,%d3),%fp2 |mul by 10**(d3_bit_no)
l_next:
 addl #12,%d3  |inc d3 to next pwrten table entry
 tstl %d0  |test if LEN is zero
 bnes l_loop  |if not, loop
|
| 10^LEN-1 is computed for this test and A14.  If the input was
| denormalized, check only the case in which YINT > 10^LEN.
|
 tstb BINDEC_FLG(%a6) |check if input was norm
 beqs A13_con  |if norm, continue with checking
 fabsx %fp0  |take abs of YINT
 bra test_2
|
| Compare abs(YINT) to 10^(LEN-1) and 10^LEN
|
A13_con:
 fabsx %fp0  |take abs of YINT
 fcmpx %fp2,%fp0  |compare abs(YINT) with 10^(LEN-1)
 fbge test_2  |if greater, do next test
 subql #1,%d6  |subtract 1 from ILOG
 movew #1,%d5  |set ICTR
 fmovel #rm_mode,%FPCR |set rmode to RM
 fmuls FTEN,%fp2 |compute 10^LEN
 bra A6_str  |return to A6 and recompute YINT
test_2:
 fmuls FTEN,%fp2 |compute 10^LEN
 fcmpx %fp2,%fp0  |compare abs(YINT) with 10^LEN
 fblt A14_st  |if less, all is ok, go to A14
 fbgt fix_ex  |if greater, fix and redo
 fdivs FTEN,%fp0 |if equal, divide by 10
 addql #1,%d6  | and inc ILOG
 bras A14_st  | and continue elsewhere
fix_ex:
 addql #1,%d6  |increment ILOG by 1
 movew #1,%d5  |set ICTR
 fmovel #rm_mode,%FPCR |set rmode to RM
 bra A6_str  |return to A6 and recompute YINT
|
| Since ICTR <> 0, we have already been through one adjustment,
| and shouldn't have another; this is to check if abs(YINT) = 10^LEN
| 10^LEN is again computed using whatever table is in a1 since the
| value calculated cannot be inexact.
|
not_zr:
 fmoves FONE,%fp2 |init fp2 to 1.0
 movel %d4,%d0  |put LEN in d0
 clrl %d3  |clr table index
z_loop:
 lsrl #1,%d0  |shift next bit into carry
 bccs z_next  |if zero, skip the mul
 fmulx (%a1,%d3),%fp2 |mul by 10**(d3_bit_no)
z_next:
 addl #12,%d3  |inc d3 to next pwrten table entry
 tstl %d0  |test if LEN is zero
 bnes z_loop  |if not, loop
 fabsx %fp0  |get abs(YINT)
 fcmpx %fp2,%fp0  |check if abs(YINT) = 10^LEN
 fbne A14_st  |if not, skip this
 fdivs FTEN,%fp0 |divide abs(YINT) by 10
 addql #1,%d6  |and inc ILOG by 1
 addql #1,%d4  | and inc LEN
 fmuls FTEN,%fp2 | if LEN++, the get 10^^LEN


| A14. Convert the mantissa to bcd.
|      The binstr routine is used to convert the LEN digit
|      mantissa to bcd in memory.  The input to binstr is
|      to be a fraction; i.e. (mantissa)/10^LEN and adjusted
|      such that the decimal point is to the left of bit 63.
|      The bcd digits are stored in the correct position in
|      the final string area in memory.
|
|
| Register usage:
| Input/Output
| d0: x/LEN call to binstr - final is 0
| d1: x/0
| d2: x/ms 32-bits of mant of abs(YINT)
| d3: x/ls 32-bits of mant of abs(YINT)
| d4: LEN/Unchanged
| d5: ICTR:LAMBDA/LAMBDA:ICTR
| d6: ILOG
| d7: k-factor/Unchanged
| a0: pointer into memory for packed bcd string formation
|     /ptr to first mantissa byte in result string
| a1: ptr to PTENxx array/Unchanged
| a2: ptr to FP_SCR2(a6)/Unchanged
| fp0: int portion of Y/abs(YINT) adjusted
| fp1: 10^ISCALE/Unchanged
| fp2: 10^LEN/Unchanged
| F_SCR1:x/Work area for final result
| F_SCR2:Y with original exponent/Unchanged
| L_SCR1:original USER_FPCR/Unchanged
| L_SCR2:first word of X packed/Unchanged

A14_st:
 fmovel #rz_mode,%FPCR |force rz for conversion
 fdivx %fp2,%fp0  |divide abs(YINT) by 10^LEN
 leal FP_SCR1(%a6),%a0
 fmovex %fp0,(%a0) |move abs(YINT)/10^LEN to memory
 movel 4(%a0),%d2 |move 2nd word of FP_RES to d2
 movel 8(%a0),%d3 |move 3rd word of FP_RES to d3
 clrl 4(%a0)  |zero word 2 of FP_RES
 clrl 8(%a0)  |zero word 3 of FP_RES
 movel (%a0),%d0  |move exponent to d0
 swap %d0  |put exponent in lower word
 beqs no_sft  |if zero, don't shift
 subil #0x3ffd,%d0 |sub bias less 2 to make fract
 tstl %d0  |check if > 1
 bgts no_sft  |if so, don't shift
 negl %d0  |make exp positive
m_loop:
 lsrl #1,%d2  |shift d2:d3 right, add 0s
 roxrl #1,%d3  |the number of places
 dbf %d0,m_loop |given in d0
no_sft:
 tstl %d2  |check for mantissa of zero
 bnes no_zr  |if not, go on
 tstl %d3  |continue zero check
 beqs zer_m  |if zero, go directly to binstr
no_zr:
 clrl %d1  |put zero in d1 for addx
 addil #0x00000080,%d3 |inc at bit 7
 addxl %d1,%d2  |continue inc
 andil #0xffffff80,%d3 |strip off lsb not used by 882
zer_m:
 movel %d4,%d0  |put LEN in d0 for binstr call
 addql #3,%a0  |a0 points to M16 byte in result
 bsr binstr  |call binstr to convert mant


| A15. Convert the exponent to bcd.
|      As in A14 above, the exp is converted to bcd and the
|      digits are stored in the final string.
|
|      Digits are stored in L_SCR1(a6) on return from BINDEC as:
|
|  32               16 15                0
| -----------------------------------------
| |  0 | e3 | e2 | e1 | e4 |  X |  X |  X |
| -----------------------------------------
|
| And are moved into their proper places in FP_SCR1.  If digit e4
| is non-zero, OPERR is signaled.  In all cases, all 4 digits are
| written as specified in the 881/882 manual for packed decimal.
|
| Register usage:
| Input/Output
| d0: x/LEN call to binstr - final is 0
| d1: x/scratch (0);shift count for final exponent packing
| d2: x/ms 32-bits of exp fraction/scratch
| d3: x/ls 32-bits of exp fraction
| d4: LEN/Unchanged
| d5: ICTR:LAMBDA/LAMBDA:ICTR
| d6: ILOG
| d7: k-factor/Unchanged
| a0: ptr to result string/ptr to L_SCR1(a6)
| a1: ptr to PTENxx array/Unchanged
| a2: ptr to FP_SCR2(a6)/Unchanged
| fp0: abs(YINT) adjusted/float(ILOG)
| fp1: 10^ISCALE/Unchanged
| fp2: 10^LEN/Unchanged
| F_SCR1:Work area for final result/BCD result
| F_SCR2:Y with original exponent/ILOG/10^4
| L_SCR1:original USER_FPCR/Exponent digits on return from binstr
| L_SCR2:first word of X packed/Unchanged

A15_st:
 tstb BINDEC_FLG(%a6) |check for denorm
 beqs not_denorm
 ftstx %fp0  |test for zero
 fbeq den_zero |if zero, use k-factor or 4933
 fmovel %d6,%fp0  |float ILOG
 fabsx %fp0  |get abs of ILOG
 bras convrt
den_zero:
 tstl %d7  |check sign of the k-factor
 blts use_ilog |if negative, use ILOG
 fmoves F4933,%fp0 |force exponent to 4933
 bras convrt  |do it
use_ilog:
 fmovel %d6,%fp0  |float ILOG
 fabsx %fp0  |get abs of ILOG
 bras convrt
not_denorm:
 ftstx %fp0  |test for zero
 fbne not_zero |if zero, force exponent
 fmoves FONE,%fp0 |force exponent to 1
 bras convrt  |do it
not_zero:
 fmovel %d6,%fp0  |float ILOG
 fabsx %fp0  |get abs of ILOG
convrt:
 fdivx 24(%a1),%fp0 |compute ILOG/10^4
 fmovex %fp0,FP_SCR2(%a6) |store fp0 in memory
 movel 4(%a2),%d2 |move word 2 to d2
 movel 8(%a2),%d3 |move word 3 to d3
 movew (%a2),%d0  |move exp to d0
 beqs x_loop_fin |if zero, skip the shift
 subiw #0x3ffd,%d0 |subtract off bias
 negw %d0  |make exp positive
x_loop:
 lsrl #1,%d2  |shift d2:d3 right
 roxrl #1,%d3  |the number of places
 dbf %d0,x_loop |given in d0
x_loop_fin:
 clrl %d1  |put zero in d1 for addx
 addil #0x00000080,%d3 |inc at bit 6
 addxl %d1,%d2  |continue inc
 andil #0xffffff80,%d3 |strip off lsb not used by 882
 movel #4,%d0  |put 4 in d0 for binstr call
 leal L_SCR1(%a6),%a0 |a0 is ptr to L_SCR1 for exp digits
 bsr binstr  |call binstr to convert exp
 movel L_SCR1(%a6),%d0 |load L_SCR1 lword to d0
 movel #12,%d1  |use d1 for shift count
 lsrl %d1,%d0  |shift d0 right by 12
 bfins %d0,FP_SCR1(%a6){#4:#12} |put e3:e2:e1 in FP_SCR1
 lsrl %d1,%d0  |shift d0 right by 12
 bfins %d0,FP_SCR1(%a6){#16:#4} |put e4 in FP_SCR1
 tstb %d0  |check if e4 is zero
 beqs A16_st  |if zero, skip rest
 orl #opaop_mask,USER_FPSR(%a6) |set OPERR & AIOP in USER_FPSR


| A16. Write sign bits to final string.
|    Sigma is bit 31 of initial value; RHO is bit 31 of d6 (ILOG).
|
| Register usage:
| Input/Output
| d0: x/scratch - final is x
| d2: x/x
| d3: x/x
| d4: LEN/Unchanged
| d5: ICTR:LAMBDA/LAMBDA:ICTR
| d6: ILOG/ILOG adjusted
| d7: k-factor/Unchanged
| a0: ptr to L_SCR1(a6)/Unchanged
| a1: ptr to PTENxx array/Unchanged
| a2: ptr to FP_SCR2(a6)/Unchanged
| fp0: float(ILOG)/Unchanged
| fp1: 10^ISCALE/Unchanged
| fp2: 10^LEN/Unchanged
| F_SCR1:BCD result with correct signs
| F_SCR2:ILOG/10^4
| L_SCR1:Exponent digits on return from binstr
| L_SCR2:first word of X packed/Unchanged

A16_st:
 clrl %d0  |clr d0 for collection of signs
 andib #0x0f,FP_SCR1(%a6) |clear first nibble of FP_SCR1
 tstl L_SCR2(%a6) |check sign of original mantissa
 bges mant_p  |if pos, don't set SM
 moveql #2,%d0  |move 2 in to d0 for SM
mant_p:
 tstl %d6  |check sign of ILOG
 bges wr_sgn  |if pos, don't set SE
 addql #1,%d0  |set bit 0 in d0 for SE
wr_sgn:
 bfins %d0,FP_SCR1(%a6){#0:#2} |insert SM and SE into FP_SCR1

| Clean up and restore all registers used.

 fmovel #0,%FPSR  |clear possible inex2/ainex bits
 fmovemx (%a7)+,%fp0-%fp2
 moveml (%a7)+,%d2-%d7/%a2
 rts

 |end