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