|
  |	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
  |
  |       For details on the license for this file, please see the
  |       file, README, in this same directory.
  
  |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
  	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 up to 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