diff options
Diffstat (limited to 'c/src/lib/libcpu/m68k/m68040/fpsp/bindec.S')
| -rw-r--r-- | c/src/lib/libcpu/m68k/m68040/fpsp/bindec.S | 922 |
1 files changed, 0 insertions, 922 deletions
diff --git a/c/src/lib/libcpu/m68k/m68040/fpsp/bindec.S b/c/src/lib/libcpu/m68k/m68040/fpsp/bindec.S deleted file mode 100644 index 4c3407394c..0000000000 --- a/c/src/lib/libcpu/m68k/m68040/fpsp/bindec.S +++ /dev/null @@ -1,922 +0,0 @@ -#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 |