forked from Imagelibrary/rtems
923 lines
28 KiB
ArmAsm
923 lines
28 KiB
ArmAsm
#include "fpsp-namespace.h"
|
|
//
|
|
//
|
|
// 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
|
|
//
|
|
// THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
|
|
// The copyright notice above does not evidence any
|
|
// actual or intended publication of such source code.
|
|
|
|
//BINDEC idnt 2,1 | Motorola 040 Floating Point Software Package
|
|
|
|
#include "fpsp.defs"
|
|
|
|
|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 upto 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
|