#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