forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
919 lines
28 KiB
919 lines
28 KiB
| |
|
| 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
|
|
|