bindec.s

VXWORKS源代码

/* bindec.s - Motorola 68040 FP binary/decimal conversion routines (EXC) */

/* Copyright 1991-1993 Wind River Systems, Inc. */
	.data
	.globl	_copyright_wind_river
	.long	_copyright_wind_river

/*
modification history
--------------------
01e,21jul93,kdl  added .text (SPR #2372).
01d,23aug92,jcf  changed bxxx to jxx.
01c,26may92,rrr  the tree shuffle
01b,10jan92,kdl  general cleanup.
01b,01jan92,jcf	 reversed order of cmp <reg>,<reg>
01a,12aug91,kdl	 changed routine names which begin "Ax_" to aboid
		 confusion when converting to lower case reg names.
*/

/*
DESCRIPTION

	__x_bindecsa 3.4 1/3/91

	__x_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 occured.  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 __x_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 __x_binstr routine is used to convert the LEN digit
		mantissa to bcd in memory.  The input to __x_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 __x_binstr
		d1: scratch
		d2: upper 32-bits of mantissa for __x_binstr
		d3: scratch| lower 32-bits of mantissa for __x_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

NOMANUAL
*/

#include "fpsp040E.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	__x_binstr
|	xref	__x_sintdo
|	xref	ptenrn,ptenrm,ptenrp

	.globl	__x_bindec
	.globl	__x_sc_mul

	.text

__x_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@,a6@(L_SCR2)	| save exponent for sign check
	movel	d0,d7		| move k-factor to d7
	clrb	a6@(BINDEC_FLG)	| clr norm/denorm flag
	movew	a6@(STAG),d0	| get stag
	andiw	#0xe000,d0	| isolate stag bits
	jeq 	__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	a0@(4),d1
	movel	a0@(8),d2
__x_norm_loop:
	subw	#1,d0
	lsll	#1,d2
	roxll	#1,d1
	tstl	d1
	jge 	__x_norm_loop
|
| Test if the normalized input is denormalized
|
	tstw	d0
	jgt 	pos_exp		| if greater than zero, it is a norm
	st	a6@(BINDEC_FLG)	| set flag for denorm
pos_exp:
	andiw	#0x7fff,d0	| strip sign of normalized exp
	movew	d0,a0@
	movel	d1,a0@(4)
	movel	d2,a0@(8)

| A2. Set X = abs(input).
|
__A2_str:
	movel	a0@,a6@(FP_SCR2) |  move input to work space
	movel	a0@(4),a6@(FP_SCR2+4) |  move input to work space
	movel	a0@(8),a6@(FP_SCR2+8) |  move input to work space
	andil	#0x7fffffff,a6@(FP_SCR2) | 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 0x3fff exponent
|	L_SCR1:x/x
|	L_SCR2:first word of X packed/Unchanged

	tstb	a6@(BINDEC_FLG)	| check for denorm
	jeq 	__A3_cont		| if clr, continue with norm
	movel	#-4933,d6	| force ILOG = -4933
	jra 	__A4_str
__A3_cont:
	movew	a6@(FP_SCR2),d0	| move exp to d0
	movew	#0x3fff,a6@(FP_SCR2) | replace exponent with 0x3fff
	fmovex	a6@(FP_SCR2),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
	jra 	__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 0x3fff exponent/Unchanged
|	L_SCR1:x/x
|	L_SCR2:first word of X packed/Unchanged

__A6_str:
	tstl	d7		| branch on sign of k
	jle 	k_neg		| if k <= 0, LEN = ILOG + 1 - k
	movel	d7,d4		| if k > 0, LEN = k
	jra 	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
	jle 	LEN_ng		| if neg, set LEN = 1
	cmpl	#17,d4		| test if LEN > 17
	jle 	__A7_str		| if not, forget it
	movel	#17,d4		| set max LEN = 17
	tstl	d7		| if negative, never set OPERR
	jle 	__A7_str	| if positive, continue
	orl	#opaop_mask,a6@(USER_FPSR) | set OPERR # AIOP in USER_FPSR
	jra 	__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 __x_bindecsa 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 __x_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 __x_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 0x3fff exponent/Unchanged
|	L_SCR1:x/x
|	L_SCR2:first word of X packed/Unchanged

__A7_str:
	tstl	d7		| test sign of k
	jgt 	k_pos		| if pos and > 0, skip this
	cmpl	d6,d7		| test ILOG - k
	jlt 	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
	jge 	iscale		| if pos, skip next inst
	addqw	#1,d5		| if neg, set LAMBDA true
	cmpl	#0xffffecd4,d0	| test iscale <= -4908
	jgt 	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	a6@(USER_FPCR){#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	a6@(L_SCR2)	| test sign of original x
	jge 	x_pos		/* | if pos, don't set bit 0 */
	addql	#1,d1		| if neg, set bit 0
x_pos:
	lea	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
	jne 	not_rn		| if zero, it is RN
	lea	__x_PTENRN,a1	| load a1 with RN table base
	jra 	rmode		| exit decode
not_rn:
	lsrb	#1,d3		| get lsb in carry
	jcc 	not_rp		| if carry clear, it is RM
	lea	__x_PTENRP,a1	| load a1 with RP table base
	jra 	rmode		| exit decode
not_rp:
	lea	__x_PTENRM,a1	| load a1 with RM table base
rmode:
	clrl	d3		| clr table index
e_loop:
	lsrl	#1,d0		| shift next bit into carry
	jcc 	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 __x_pwrten table entry
	tstl	d0		| test if ISCALE is zero
	jne 	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