xref: /openbmc/linux/arch/m68k/fpsp040/bindec.S (revision 25985edc)
1|
2|	bindec.sa 3.4 1/3/91
3|
4|	bindec
5|
6|	Description:
7|		Converts an input in extended precision format
8|		to bcd format.
9|
10|	Input:
11|		a0 points to the input extended precision value
12|		value in memory; d0 contains the k-factor sign-extended
13|		to 32-bits.  The input may be either normalized,
14|		unnormalized, or denormalized.
15|
16|	Output:	result in the FP_SCR1 space on the stack.
17|
18|	Saves and Modifies: D2-D7,A2,FP2
19|
20|	Algorithm:
21|
22|	A1.	Set RM and size ext;  Set SIGMA = sign of input.
23|		The k-factor is saved for use in d7. Clear the
24|		BINDEC_FLG for separating normalized/denormalized
25|		input.  If input is unnormalized or denormalized,
26|		normalize it.
27|
28|	A2.	Set X = abs(input).
29|
30|	A3.	Compute ILOG.
31|		ILOG is the log base 10 of the input value.  It is
32|		approximated by adding e + 0.f when the original
33|		value is viewed as 2^^e * 1.f in extended precision.
34|		This value is stored in d6.
35|
36|	A4.	Clr INEX bit.
37|		The operation in A3 above may have set INEX2.
38|
39|	A5.	Set ICTR = 0;
40|		ICTR is a flag used in A13.  It must be set before the
41|		loop entry A6.
42|
43|	A6.	Calculate LEN.
44|		LEN is the number of digits to be displayed.  The
45|		k-factor can dictate either the total number of digits,
46|		if it is a positive number, or the number of digits
47|		after the decimal point which are to be included as
48|		significant.  See the 68882 manual for examples.
49|		If LEN is computed to be greater than 17, set OPERR in
50|		USER_FPSR.  LEN is stored in d4.
51|
52|	A7.	Calculate SCALE.
53|		SCALE is equal to 10^ISCALE, where ISCALE is the number
54|		of decimal places needed to insure LEN integer digits
55|		in the output before conversion to bcd. LAMBDA is the
56|		sign of ISCALE, used in A9. Fp1 contains
57|		10^^(abs(ISCALE)) using a rounding mode which is a
58|		function of the original rounding mode and the signs
59|		of ISCALE and X.  A table is given in the code.
60|
61|	A8.	Clr INEX; Force RZ.
62|		The operation in A3 above may have set INEX2.
63|		RZ mode is forced for the scaling operation to insure
64|		only one rounding error.  The grs bits are collected in
65|		the INEX flag for use in A10.
66|
67|	A9.	Scale X -> Y.
68|		The mantissa is scaled to the desired number of
69|		significant digits.  The excess digits are collected
70|		in INEX2.
71|
72|	A10.	Or in INEX.
73|		If INEX is set, round error occurred.  This is
74|		compensated for by 'or-ing' in the INEX2 flag to
75|		the lsb of Y.
76|
77|	A11.	Restore original FPCR; set size ext.
78|		Perform FINT operation in the user's rounding mode.
79|		Keep the size to extended.
80|
81|	A12.	Calculate YINT = FINT(Y) according to user's rounding
82|		mode.  The FPSP routine sintd0 is used.  The output
83|		is in fp0.
84|
85|	A13.	Check for LEN digits.
86|		If the int operation results in more than LEN digits,
87|		or less than LEN -1 digits, adjust ILOG and repeat from
88|		A6.  This test occurs only on the first pass.  If the
89|		result is exactly 10^LEN, decrement ILOG and divide
90|		the mantissa by 10.
91|
92|	A14.	Convert the mantissa to bcd.
93|		The binstr routine is used to convert the LEN digit
94|		mantissa to bcd in memory.  The input to binstr is
95|		to be a fraction; i.e. (mantissa)/10^LEN and adjusted
96|		such that the decimal point is to the left of bit 63.
97|		The bcd digits are stored in the correct position in
98|		the final string area in memory.
99|
100|	A15.	Convert the exponent to bcd.
101|		As in A14 above, the exp is converted to bcd and the
102|		digits are stored in the final string.
103|		Test the length of the final exponent string.  If the
104|		length is 4, set operr.
105|
106|	A16.	Write sign bits to final string.
107|
108|	Implementation Notes:
109|
110|	The registers are used as follows:
111|
112|		d0: scratch; LEN input to binstr
113|		d1: scratch
114|		d2: upper 32-bits of mantissa for binstr
115|		d3: scratch;lower 32-bits of mantissa for binstr
116|		d4: LEN
117|		d5: LAMBDA/ICTR
118|		d6: ILOG
119|		d7: k-factor
120|		a0: ptr for original operand/final result
121|		a1: scratch pointer
122|		a2: pointer to FP_X; abs(original value) in ext
123|		fp0: scratch
124|		fp1: scratch
125|		fp2: scratch
126|		F_SCR1:
127|		F_SCR2:
128|		L_SCR1:
129|		L_SCR2:
130
131|		Copyright (C) Motorola, Inc. 1990
132|			All Rights Reserved
133|
134|       For details on the license for this file, please see the
135|       file, README, in this same directory.
136
137|BINDEC    idnt    2,1 | Motorola 040 Floating Point Software Package
138
139#include "fpsp.h"
140
141	|section	8
142
143| Constants in extended precision
144LOG2:	.long	0x3FFD0000,0x9A209A84,0xFBCFF798,0x00000000
145LOG2UP1:	.long	0x3FFD0000,0x9A209A84,0xFBCFF799,0x00000000
146
147| Constants in single precision
148FONE:	.long	0x3F800000,0x00000000,0x00000000,0x00000000
149FTWO:	.long	0x40000000,0x00000000,0x00000000,0x00000000
150FTEN:	.long	0x41200000,0x00000000,0x00000000,0x00000000
151F4933:	.long	0x459A2800,0x00000000,0x00000000,0x00000000
152
153RBDTBL:	.byte	0,0,0,0
154	.byte	3,3,2,2
155	.byte	3,2,2,3
156	.byte	2,3,3,2
157
158	|xref	binstr
159	|xref	sintdo
160	|xref	ptenrn,ptenrm,ptenrp
161
162	.global	bindec
163	.global	sc_mul
164bindec:
165	moveml	%d2-%d7/%a2,-(%a7)
166	fmovemx %fp0-%fp2,-(%a7)
167
168| A1. Set RM and size ext. Set SIGMA = sign input;
169|     The k-factor is saved for use in d7.  Clear BINDEC_FLG for
170|     separating  normalized/denormalized input.  If the input
171|     is a denormalized number, set the BINDEC_FLG memory word
172|     to signal denorm.  If the input is unnormalized, normalize
173|     the input and test for denormalized result.
174|
175	fmovel	#rm_mode,%FPCR	|set RM and ext
176	movel	(%a0),L_SCR2(%a6)	|save exponent for sign check
177	movel	%d0,%d7		|move k-factor to d7
178	clrb	BINDEC_FLG(%a6)	|clr norm/denorm flag
179	movew	STAG(%a6),%d0	|get stag
180	andiw	#0xe000,%d0	|isolate stag bits
181	beq	A2_str		|if zero, input is norm
182|
183| Normalize the denorm
184|
185un_de_norm:
186	movew	(%a0),%d0
187	andiw	#0x7fff,%d0	|strip sign of normalized exp
188	movel	4(%a0),%d1
189	movel	8(%a0),%d2
190norm_loop:
191	subw	#1,%d0
192	lsll	#1,%d2
193	roxll	#1,%d1
194	tstl	%d1
195	bges	norm_loop
196|
197| Test if the normalized input is denormalized
198|
199	tstw	%d0
200	bgts	pos_exp		|if greater than zero, it is a norm
201	st	BINDEC_FLG(%a6)	|set flag for denorm
202pos_exp:
203	andiw	#0x7fff,%d0	|strip sign of normalized exp
204	movew	%d0,(%a0)
205	movel	%d1,4(%a0)
206	movel	%d2,8(%a0)
207
208| A2. Set X = abs(input).
209|
210A2_str:
211	movel	(%a0),FP_SCR2(%a6) | move input to work space
212	movel	4(%a0),FP_SCR2+4(%a6) | move input to work space
213	movel	8(%a0),FP_SCR2+8(%a6) | move input to work space
214	andil	#0x7fffffff,FP_SCR2(%a6) |create abs(X)
215
216| A3. Compute ILOG.
217|     ILOG is the log base 10 of the input value.  It is approx-
218|     imated by adding e + 0.f when the original value is viewed
219|     as 2^^e * 1.f in extended precision.  This value is stored
220|     in d6.
221|
222| Register usage:
223|	Input/Output
224|	d0: k-factor/exponent
225|	d2: x/x
226|	d3: x/x
227|	d4: x/x
228|	d5: x/x
229|	d6: x/ILOG
230|	d7: k-factor/Unchanged
231|	a0: ptr for original operand/final result
232|	a1: x/x
233|	a2: x/x
234|	fp0: x/float(ILOG)
235|	fp1: x/x
236|	fp2: x/x
237|	F_SCR1:x/x
238|	F_SCR2:Abs(X)/Abs(X) with $3fff exponent
239|	L_SCR1:x/x
240|	L_SCR2:first word of X packed/Unchanged
241
242	tstb	BINDEC_FLG(%a6)	|check for denorm
243	beqs	A3_cont		|if clr, continue with norm
244	movel	#-4933,%d6	|force ILOG = -4933
245	bras	A4_str
246A3_cont:
247	movew	FP_SCR2(%a6),%d0	|move exp to d0
248	movew	#0x3fff,FP_SCR2(%a6) |replace exponent with 0x3fff
249	fmovex	FP_SCR2(%a6),%fp0	|now fp0 has 1.f
250	subw	#0x3fff,%d0	|strip off bias
251	faddw	%d0,%fp0		|add in exp
252	fsubs	FONE,%fp0	|subtract off 1.0
253	fbge	pos_res		|if pos, branch
254	fmulx	LOG2UP1,%fp0	|if neg, mul by LOG2UP1
255	fmovel	%fp0,%d6		|put ILOG in d6 as a lword
256	bras	A4_str		|go move out ILOG
257pos_res:
258	fmulx	LOG2,%fp0	|if pos, mul by LOG2
259	fmovel	%fp0,%d6		|put ILOG in d6 as a lword
260
261
262| A4. Clr INEX bit.
263|     The operation in A3 above may have set INEX2.
264
265A4_str:
266	fmovel	#0,%FPSR		|zero all of fpsr - nothing needed
267
268
269| A5. Set ICTR = 0;
270|     ICTR is a flag used in A13.  It must be set before the
271|     loop entry A6. The lower word of d5 is used for ICTR.
272
273	clrw	%d5		|clear ICTR
274
275
276| A6. Calculate LEN.
277|     LEN is the number of digits to be displayed.  The k-factor
278|     can dictate either the total number of digits, if it is
279|     a positive number, or the number of digits after the
280|     original decimal point which are to be included as
281|     significant.  See the 68882 manual for examples.
282|     If LEN is computed to be greater than 17, set OPERR in
283|     USER_FPSR.  LEN is stored in d4.
284|
285| Register usage:
286|	Input/Output
287|	d0: exponent/Unchanged
288|	d2: x/x/scratch
289|	d3: x/x
290|	d4: exc picture/LEN
291|	d5: ICTR/Unchanged
292|	d6: ILOG/Unchanged
293|	d7: k-factor/Unchanged
294|	a0: ptr for original operand/final result
295|	a1: x/x
296|	a2: x/x
297|	fp0: float(ILOG)/Unchanged
298|	fp1: x/x
299|	fp2: x/x
300|	F_SCR1:x/x
301|	F_SCR2:Abs(X) with $3fff exponent/Unchanged
302|	L_SCR1:x/x
303|	L_SCR2:first word of X packed/Unchanged
304
305A6_str:
306	tstl	%d7		|branch on sign of k
307	bles	k_neg		|if k <= 0, LEN = ILOG + 1 - k
308	movel	%d7,%d4		|if k > 0, LEN = k
309	bras	len_ck		|skip to LEN check
310k_neg:
311	movel	%d6,%d4		|first load ILOG to d4
312	subl	%d7,%d4		|subtract off k
313	addql	#1,%d4		|add in the 1
314len_ck:
315	tstl	%d4		|LEN check: branch on sign of LEN
316	bles	LEN_ng		|if neg, set LEN = 1
317	cmpl	#17,%d4		|test if LEN > 17
318	bles	A7_str		|if not, forget it
319	movel	#17,%d4		|set max LEN = 17
320	tstl	%d7		|if negative, never set OPERR
321	bles	A7_str		|if positive, continue
322	orl	#opaop_mask,USER_FPSR(%a6) |set OPERR & AIOP in USER_FPSR
323	bras	A7_str		|finished here
324LEN_ng:
325	moveql	#1,%d4		|min LEN is 1
326
327
328| A7. Calculate SCALE.
329|     SCALE is equal to 10^ISCALE, where ISCALE is the number
330|     of decimal places needed to insure LEN integer digits
331|     in the output before conversion to bcd. LAMBDA is the sign
332|     of ISCALE, used in A9.  Fp1 contains 10^^(abs(ISCALE)) using
333|     the rounding mode as given in the following table (see
334|     Coonen, p. 7.23 as ref.; however, the SCALE variable is
335|     of opposite sign in bindec.sa from Coonen).
336|
337|	Initial					USE
338|	FPCR[6:5]	LAMBDA	SIGN(X)		FPCR[6:5]
339|	----------------------------------------------
340|	 RN	00	   0	   0		00/0	RN
341|	 RN	00	   0	   1		00/0	RN
342|	 RN	00	   1	   0		00/0	RN
343|	 RN	00	   1	   1		00/0	RN
344|	 RZ	01	   0	   0		11/3	RP
345|	 RZ	01	   0	   1		11/3	RP
346|	 RZ	01	   1	   0		10/2	RM
347|	 RZ	01	   1	   1		10/2	RM
348|	 RM	10	   0	   0		11/3	RP
349|	 RM	10	   0	   1		10/2	RM
350|	 RM	10	   1	   0		10/2	RM
351|	 RM	10	   1	   1		11/3	RP
352|	 RP	11	   0	   0		10/2	RM
353|	 RP	11	   0	   1		11/3	RP
354|	 RP	11	   1	   0		11/3	RP
355|	 RP	11	   1	   1		10/2	RM
356|
357| Register usage:
358|	Input/Output
359|	d0: exponent/scratch - final is 0
360|	d2: x/0 or 24 for A9
361|	d3: x/scratch - offset ptr into PTENRM array
362|	d4: LEN/Unchanged
363|	d5: 0/ICTR:LAMBDA
364|	d6: ILOG/ILOG or k if ((k<=0)&(ILOG<k))
365|	d7: k-factor/Unchanged
366|	a0: ptr for original operand/final result
367|	a1: x/ptr to PTENRM array
368|	a2: x/x
369|	fp0: float(ILOG)/Unchanged
370|	fp1: x/10^ISCALE
371|	fp2: x/x
372|	F_SCR1:x/x
373|	F_SCR2:Abs(X) with $3fff exponent/Unchanged
374|	L_SCR1:x/x
375|	L_SCR2:first word of X packed/Unchanged
376
377A7_str:
378	tstl	%d7		|test sign of k
379	bgts	k_pos		|if pos and > 0, skip this
380	cmpl	%d6,%d7		|test k - ILOG
381	blts	k_pos		|if ILOG >= k, skip this
382	movel	%d7,%d6		|if ((k<0) & (ILOG < k)) ILOG = k
383k_pos:
384	movel	%d6,%d0		|calc ILOG + 1 - LEN in d0
385	addql	#1,%d0		|add the 1
386	subl	%d4,%d0		|sub off LEN
387	swap	%d5		|use upper word of d5 for LAMBDA
388	clrw	%d5		|set it zero initially
389	clrw	%d2		|set up d2 for very small case
390	tstl	%d0		|test sign of ISCALE
391	bges	iscale		|if pos, skip next inst
392	addqw	#1,%d5		|if neg, set LAMBDA true
393	cmpl	#0xffffecd4,%d0	|test iscale <= -4908
394	bgts	no_inf		|if false, skip rest
395	addil	#24,%d0		|add in 24 to iscale
396	movel	#24,%d2		|put 24 in d2 for A9
397no_inf:
398	negl	%d0		|and take abs of ISCALE
399iscale:
400	fmoves	FONE,%fp1	|init fp1 to 1
401	bfextu	USER_FPCR(%a6){#26:#2},%d1 |get initial rmode bits
402	lslw	#1,%d1		|put them in bits 2:1
403	addw	%d5,%d1		|add in LAMBDA
404	lslw	#1,%d1		|put them in bits 3:1
405	tstl	L_SCR2(%a6)	|test sign of original x
406	bges	x_pos		|if pos, don't set bit 0
407	addql	#1,%d1		|if neg, set bit 0
408x_pos:
409	leal	RBDTBL,%a2	|load rbdtbl base
410	moveb	(%a2,%d1),%d3	|load d3 with new rmode
411	lsll	#4,%d3		|put bits in proper position
412	fmovel	%d3,%fpcr		|load bits into fpu
413	lsrl	#4,%d3		|put bits in proper position
414	tstb	%d3		|decode new rmode for pten table
415	bnes	not_rn		|if zero, it is RN
416	leal	PTENRN,%a1	|load a1 with RN table base
417	bras	rmode		|exit decode
418not_rn:
419	lsrb	#1,%d3		|get lsb in carry
420	bccs	not_rp		|if carry clear, it is RM
421	leal	PTENRP,%a1	|load a1 with RP table base
422	bras	rmode		|exit decode
423not_rp:
424	leal	PTENRM,%a1	|load a1 with RM table base
425rmode:
426	clrl	%d3		|clr table index
427e_loop:
428	lsrl	#1,%d0		|shift next bit into carry
429	bccs	e_next		|if zero, skip the mul
430	fmulx	(%a1,%d3),%fp1	|mul by 10**(d3_bit_no)
431e_next:
432	addl	#12,%d3		|inc d3 to next pwrten table entry
433	tstl	%d0		|test if ISCALE is zero
434	bnes	e_loop		|if not, loop
435
436
437| A8. Clr INEX; Force RZ.
438|     The operation in A3 above may have set INEX2.
439|     RZ mode is forced for the scaling operation to insure
440|     only one rounding error.  The grs bits are collected in
441|     the INEX flag for use in A10.
442|
443| Register usage:
444|	Input/Output
445
446	fmovel	#0,%FPSR		|clr INEX
447	fmovel	#rz_mode,%FPCR	|set RZ rounding mode
448
449
450| A9. Scale X -> Y.
451|     The mantissa is scaled to the desired number of significant
452|     digits.  The excess digits are collected in INEX2. If mul,
453|     Check d2 for excess 10 exponential value.  If not zero,
454|     the iscale value would have caused the pwrten calculation
455|     to overflow.  Only a negative iscale can cause this, so
456|     multiply by 10^(d2), which is now only allowed to be 24,
457|     with a multiply by 10^8 and 10^16, which is exact since
458|     10^24 is exact.  If the input was denormalized, we must
459|     create a busy stack frame with the mul command and the
460|     two operands, and allow the fpu to complete the multiply.
461|
462| Register usage:
463|	Input/Output
464|	d0: FPCR with RZ mode/Unchanged
465|	d2: 0 or 24/unchanged
466|	d3: x/x
467|	d4: LEN/Unchanged
468|	d5: ICTR:LAMBDA
469|	d6: ILOG/Unchanged
470|	d7: k-factor/Unchanged
471|	a0: ptr for original operand/final result
472|	a1: ptr to PTENRM array/Unchanged
473|	a2: x/x
474|	fp0: float(ILOG)/X adjusted for SCALE (Y)
475|	fp1: 10^ISCALE/Unchanged
476|	fp2: x/x
477|	F_SCR1:x/x
478|	F_SCR2:Abs(X) with $3fff exponent/Unchanged
479|	L_SCR1:x/x
480|	L_SCR2:first word of X packed/Unchanged
481
482A9_str:
483	fmovex	(%a0),%fp0	|load X from memory
484	fabsx	%fp0		|use abs(X)
485	tstw	%d5		|LAMBDA is in lower word of d5
486	bne	sc_mul		|if neg (LAMBDA = 1), scale by mul
487	fdivx	%fp1,%fp0		|calculate X / SCALE -> Y to fp0
488	bras	A10_st		|branch to A10
489
490sc_mul:
491	tstb	BINDEC_FLG(%a6)	|check for denorm
492	beqs	A9_norm		|if norm, continue with mul
493	fmovemx %fp1-%fp1,-(%a7)	|load ETEMP with 10^ISCALE
494	movel	8(%a0),-(%a7)	|load FPTEMP with input arg
495	movel	4(%a0),-(%a7)
496	movel	(%a0),-(%a7)
497	movel	#18,%d3		|load count for busy stack
498A9_loop:
499	clrl	-(%a7)		|clear lword on stack
500	dbf	%d3,A9_loop
501	moveb	VER_TMP(%a6),(%a7) |write current version number
502	moveb	#BUSY_SIZE-4,1(%a7) |write current busy size
503	moveb	#0x10,0x44(%a7)	|set fcefpte[15] bit
504	movew	#0x0023,0x40(%a7)	|load cmdreg1b with mul command
505	moveb	#0xfe,0x8(%a7)	|load all 1s to cu savepc
506	frestore (%a7)+		|restore frame to fpu for completion
507	fmulx	36(%a1),%fp0	|multiply fp0 by 10^8
508	fmulx	48(%a1),%fp0	|multiply fp0 by 10^16
509	bras	A10_st
510A9_norm:
511	tstw	%d2		|test for small exp case
512	beqs	A9_con		|if zero, continue as normal
513	fmulx	36(%a1),%fp0	|multiply fp0 by 10^8
514	fmulx	48(%a1),%fp0	|multiply fp0 by 10^16
515A9_con:
516	fmulx	%fp1,%fp0		|calculate X * SCALE -> Y to fp0
517
518
519| A10. Or in INEX.
520|      If INEX is set, round error occurred.  This is compensated
521|      for by 'or-ing' in the INEX2 flag to the lsb of Y.
522|
523| Register usage:
524|	Input/Output
525|	d0: FPCR with RZ mode/FPSR with INEX2 isolated
526|	d2: x/x
527|	d3: x/x
528|	d4: LEN/Unchanged
529|	d5: ICTR:LAMBDA
530|	d6: ILOG/Unchanged
531|	d7: k-factor/Unchanged
532|	a0: ptr for original operand/final result
533|	a1: ptr to PTENxx array/Unchanged
534|	a2: x/ptr to FP_SCR2(a6)
535|	fp0: Y/Y with lsb adjusted
536|	fp1: 10^ISCALE/Unchanged
537|	fp2: x/x
538
539A10_st:
540	fmovel	%FPSR,%d0		|get FPSR
541	fmovex	%fp0,FP_SCR2(%a6)	|move Y to memory
542	leal	FP_SCR2(%a6),%a2	|load a2 with ptr to FP_SCR2
543	btstl	#9,%d0		|check if INEX2 set
544	beqs	A11_st		|if clear, skip rest
545	oril	#1,8(%a2)	|or in 1 to lsb of mantissa
546	fmovex	FP_SCR2(%a6),%fp0	|write adjusted Y back to fpu
547
548
549| A11. Restore original FPCR; set size ext.
550|      Perform FINT operation in the user's rounding mode.  Keep
551|      the size to extended.  The sintdo entry point in the sint
552|      routine expects the FPCR value to be in USER_FPCR for
553|      mode and precision.  The original FPCR is saved in L_SCR1.
554
555A11_st:
556	movel	USER_FPCR(%a6),L_SCR1(%a6) |save it for later
557	andil	#0x00000030,USER_FPCR(%a6) |set size to ext,
558|					;block exceptions
559
560
561| A12. Calculate YINT = FINT(Y) according to user's rounding mode.
562|      The FPSP routine sintd0 is used.  The output is in fp0.
563|
564| Register usage:
565|	Input/Output
566|	d0: FPSR with AINEX cleared/FPCR with size set to ext
567|	d2: x/x/scratch
568|	d3: x/x
569|	d4: LEN/Unchanged
570|	d5: ICTR:LAMBDA/Unchanged
571|	d6: ILOG/Unchanged
572|	d7: k-factor/Unchanged
573|	a0: ptr for original operand/src ptr for sintdo
574|	a1: ptr to PTENxx array/Unchanged
575|	a2: ptr to FP_SCR2(a6)/Unchanged
576|	a6: temp pointer to FP_SCR2(a6) - orig value saved and restored
577|	fp0: Y/YINT
578|	fp1: 10^ISCALE/Unchanged
579|	fp2: x/x
580|	F_SCR1:x/x
581|	F_SCR2:Y adjusted for inex/Y with original exponent
582|	L_SCR1:x/original USER_FPCR
583|	L_SCR2:first word of X packed/Unchanged
584
585A12_st:
586	moveml	%d0-%d1/%a0-%a1,-(%a7)	|save regs used by sintd0
587	movel	L_SCR1(%a6),-(%a7)
588	movel	L_SCR2(%a6),-(%a7)
589	leal	FP_SCR2(%a6),%a0		|a0 is ptr to F_SCR2(a6)
590	fmovex	%fp0,(%a0)		|move Y to memory at FP_SCR2(a6)
591	tstl	L_SCR2(%a6)		|test sign of original operand
592	bges	do_fint			|if pos, use Y
593	orl	#0x80000000,(%a0)		|if neg, use -Y
594do_fint:
595	movel	USER_FPSR(%a6),-(%a7)
596	bsr	sintdo			|sint routine returns int in fp0
597	moveb	(%a7),USER_FPSR(%a6)
598	addl	#4,%a7
599	movel	(%a7)+,L_SCR2(%a6)
600	movel	(%a7)+,L_SCR1(%a6)
601	moveml	(%a7)+,%d0-%d1/%a0-%a1	|restore regs used by sint
602	movel	L_SCR2(%a6),FP_SCR2(%a6)	|restore original exponent
603	movel	L_SCR1(%a6),USER_FPCR(%a6) |restore user's FPCR
604
605
606| A13. Check for LEN digits.
607|      If the int operation results in more than LEN digits,
608|      or less than LEN -1 digits, adjust ILOG and repeat from
609|      A6.  This test occurs only on the first pass.  If the
610|      result is exactly 10^LEN, decrement ILOG and divide
611|      the mantissa by 10.  The calculation of 10^LEN cannot
612|      be inexact, since all powers of ten up to 10^27 are exact
613|      in extended precision, so the use of a previous power-of-ten
614|      table will introduce no error.
615|
616|
617| Register usage:
618|	Input/Output
619|	d0: FPCR with size set to ext/scratch final = 0
620|	d2: x/x
621|	d3: x/scratch final = x
622|	d4: LEN/LEN adjusted
623|	d5: ICTR:LAMBDA/LAMBDA:ICTR
624|	d6: ILOG/ILOG adjusted
625|	d7: k-factor/Unchanged
626|	a0: pointer into memory for packed bcd string formation
627|	a1: ptr to PTENxx array/Unchanged
628|	a2: ptr to FP_SCR2(a6)/Unchanged
629|	fp0: int portion of Y/abs(YINT) adjusted
630|	fp1: 10^ISCALE/Unchanged
631|	fp2: x/10^LEN
632|	F_SCR1:x/x
633|	F_SCR2:Y with original exponent/Unchanged
634|	L_SCR1:original USER_FPCR/Unchanged
635|	L_SCR2:first word of X packed/Unchanged
636
637A13_st:
638	swap	%d5		|put ICTR in lower word of d5
639	tstw	%d5		|check if ICTR = 0
640	bne	not_zr		|if non-zero, go to second test
641|
642| Compute 10^(LEN-1)
643|
644	fmoves	FONE,%fp2	|init fp2 to 1.0
645	movel	%d4,%d0		|put LEN in d0
646	subql	#1,%d0		|d0 = LEN -1
647	clrl	%d3		|clr table index
648l_loop:
649	lsrl	#1,%d0		|shift next bit into carry
650	bccs	l_next		|if zero, skip the mul
651	fmulx	(%a1,%d3),%fp2	|mul by 10**(d3_bit_no)
652l_next:
653	addl	#12,%d3		|inc d3 to next pwrten table entry
654	tstl	%d0		|test if LEN is zero
655	bnes	l_loop		|if not, loop
656|
657| 10^LEN-1 is computed for this test and A14.  If the input was
658| denormalized, check only the case in which YINT > 10^LEN.
659|
660	tstb	BINDEC_FLG(%a6)	|check if input was norm
661	beqs	A13_con		|if norm, continue with checking
662	fabsx	%fp0		|take abs of YINT
663	bra	test_2
664|
665| Compare abs(YINT) to 10^(LEN-1) and 10^LEN
666|
667A13_con:
668	fabsx	%fp0		|take abs of YINT
669	fcmpx	%fp2,%fp0		|compare abs(YINT) with 10^(LEN-1)
670	fbge	test_2		|if greater, do next test
671	subql	#1,%d6		|subtract 1 from ILOG
672	movew	#1,%d5		|set ICTR
673	fmovel	#rm_mode,%FPCR	|set rmode to RM
674	fmuls	FTEN,%fp2	|compute 10^LEN
675	bra	A6_str		|return to A6 and recompute YINT
676test_2:
677	fmuls	FTEN,%fp2	|compute 10^LEN
678	fcmpx	%fp2,%fp0		|compare abs(YINT) with 10^LEN
679	fblt	A14_st		|if less, all is ok, go to A14
680	fbgt	fix_ex		|if greater, fix and redo
681	fdivs	FTEN,%fp0	|if equal, divide by 10
682	addql	#1,%d6		| and inc ILOG
683	bras	A14_st		| and continue elsewhere
684fix_ex:
685	addql	#1,%d6		|increment ILOG by 1
686	movew	#1,%d5		|set ICTR
687	fmovel	#rm_mode,%FPCR	|set rmode to RM
688	bra	A6_str		|return to A6 and recompute YINT
689|
690| Since ICTR <> 0, we have already been through one adjustment,
691| and shouldn't have another; this is to check if abs(YINT) = 10^LEN
692| 10^LEN is again computed using whatever table is in a1 since the
693| value calculated cannot be inexact.
694|
695not_zr:
696	fmoves	FONE,%fp2	|init fp2 to 1.0
697	movel	%d4,%d0		|put LEN in d0
698	clrl	%d3		|clr table index
699z_loop:
700	lsrl	#1,%d0		|shift next bit into carry
701	bccs	z_next		|if zero, skip the mul
702	fmulx	(%a1,%d3),%fp2	|mul by 10**(d3_bit_no)
703z_next:
704	addl	#12,%d3		|inc d3 to next pwrten table entry
705	tstl	%d0		|test if LEN is zero
706	bnes	z_loop		|if not, loop
707	fabsx	%fp0		|get abs(YINT)
708	fcmpx	%fp2,%fp0		|check if abs(YINT) = 10^LEN
709	fbne	A14_st		|if not, skip this
710	fdivs	FTEN,%fp0	|divide abs(YINT) by 10
711	addql	#1,%d6		|and inc ILOG by 1
712	addql	#1,%d4		| and inc LEN
713	fmuls	FTEN,%fp2	| if LEN++, the get 10^^LEN
714
715
716| A14. Convert the mantissa to bcd.
717|      The binstr routine is used to convert the LEN digit
718|      mantissa to bcd in memory.  The input to binstr is
719|      to be a fraction; i.e. (mantissa)/10^LEN and adjusted
720|      such that the decimal point is to the left of bit 63.
721|      The bcd digits are stored in the correct position in
722|      the final string area in memory.
723|
724|
725| Register usage:
726|	Input/Output
727|	d0: x/LEN call to binstr - final is 0
728|	d1: x/0
729|	d2: x/ms 32-bits of mant of abs(YINT)
730|	d3: x/ls 32-bits of mant of abs(YINT)
731|	d4: LEN/Unchanged
732|	d5: ICTR:LAMBDA/LAMBDA:ICTR
733|	d6: ILOG
734|	d7: k-factor/Unchanged
735|	a0: pointer into memory for packed bcd string formation
736|	    /ptr to first mantissa byte in result string
737|	a1: ptr to PTENxx array/Unchanged
738|	a2: ptr to FP_SCR2(a6)/Unchanged
739|	fp0: int portion of Y/abs(YINT) adjusted
740|	fp1: 10^ISCALE/Unchanged
741|	fp2: 10^LEN/Unchanged
742|	F_SCR1:x/Work area for final result
743|	F_SCR2:Y with original exponent/Unchanged
744|	L_SCR1:original USER_FPCR/Unchanged
745|	L_SCR2:first word of X packed/Unchanged
746
747A14_st:
748	fmovel	#rz_mode,%FPCR	|force rz for conversion
749	fdivx	%fp2,%fp0		|divide abs(YINT) by 10^LEN
750	leal	FP_SCR1(%a6),%a0
751	fmovex	%fp0,(%a0)	|move abs(YINT)/10^LEN to memory
752	movel	4(%a0),%d2	|move 2nd word of FP_RES to d2
753	movel	8(%a0),%d3	|move 3rd word of FP_RES to d3
754	clrl	4(%a0)		|zero word 2 of FP_RES
755	clrl	8(%a0)		|zero word 3 of FP_RES
756	movel	(%a0),%d0		|move exponent to d0
757	swap	%d0		|put exponent in lower word
758	beqs	no_sft		|if zero, don't shift
759	subil	#0x3ffd,%d0	|sub bias less 2 to make fract
760	tstl	%d0		|check if > 1
761	bgts	no_sft		|if so, don't shift
762	negl	%d0		|make exp positive
763m_loop:
764	lsrl	#1,%d2		|shift d2:d3 right, add 0s
765	roxrl	#1,%d3		|the number of places
766	dbf	%d0,m_loop	|given in d0
767no_sft:
768	tstl	%d2		|check for mantissa of zero
769	bnes	no_zr		|if not, go on
770	tstl	%d3		|continue zero check
771	beqs	zer_m		|if zero, go directly to binstr
772no_zr:
773	clrl	%d1		|put zero in d1 for addx
774	addil	#0x00000080,%d3	|inc at bit 7
775	addxl	%d1,%d2		|continue inc
776	andil	#0xffffff80,%d3	|strip off lsb not used by 882
777zer_m:
778	movel	%d4,%d0		|put LEN in d0 for binstr call
779	addql	#3,%a0		|a0 points to M16 byte in result
780	bsr	binstr		|call binstr to convert mant
781
782
783| A15. Convert the exponent to bcd.
784|      As in A14 above, the exp is converted to bcd and the
785|      digits are stored in the final string.
786|
787|      Digits are stored in L_SCR1(a6) on return from BINDEC as:
788|
789|	 32               16 15                0
790|	-----------------------------------------
791|	|  0 | e3 | e2 | e1 | e4 |  X |  X |  X |
792|	-----------------------------------------
793|
794| And are moved into their proper places in FP_SCR1.  If digit e4
795| is non-zero, OPERR is signaled.  In all cases, all 4 digits are
796| written as specified in the 881/882 manual for packed decimal.
797|
798| Register usage:
799|	Input/Output
800|	d0: x/LEN call to binstr - final is 0
801|	d1: x/scratch (0);shift count for final exponent packing
802|	d2: x/ms 32-bits of exp fraction/scratch
803|	d3: x/ls 32-bits of exp fraction
804|	d4: LEN/Unchanged
805|	d5: ICTR:LAMBDA/LAMBDA:ICTR
806|	d6: ILOG
807|	d7: k-factor/Unchanged
808|	a0: ptr to result string/ptr to L_SCR1(a6)
809|	a1: ptr to PTENxx array/Unchanged
810|	a2: ptr to FP_SCR2(a6)/Unchanged
811|	fp0: abs(YINT) adjusted/float(ILOG)
812|	fp1: 10^ISCALE/Unchanged
813|	fp2: 10^LEN/Unchanged
814|	F_SCR1:Work area for final result/BCD result
815|	F_SCR2:Y with original exponent/ILOG/10^4
816|	L_SCR1:original USER_FPCR/Exponent digits on return from binstr
817|	L_SCR2:first word of X packed/Unchanged
818
819A15_st:
820	tstb	BINDEC_FLG(%a6)	|check for denorm
821	beqs	not_denorm
822	ftstx	%fp0		|test for zero
823	fbeq	den_zero	|if zero, use k-factor or 4933
824	fmovel	%d6,%fp0		|float ILOG
825	fabsx	%fp0		|get abs of ILOG
826	bras	convrt
827den_zero:
828	tstl	%d7		|check sign of the k-factor
829	blts	use_ilog	|if negative, use ILOG
830	fmoves	F4933,%fp0	|force exponent to 4933
831	bras	convrt		|do it
832use_ilog:
833	fmovel	%d6,%fp0		|float ILOG
834	fabsx	%fp0		|get abs of ILOG
835	bras	convrt
836not_denorm:
837	ftstx	%fp0		|test for zero
838	fbne	not_zero	|if zero, force exponent
839	fmoves	FONE,%fp0	|force exponent to 1
840	bras	convrt		|do it
841not_zero:
842	fmovel	%d6,%fp0		|float ILOG
843	fabsx	%fp0		|get abs of ILOG
844convrt:
845	fdivx	24(%a1),%fp0	|compute ILOG/10^4
846	fmovex	%fp0,FP_SCR2(%a6)	|store fp0 in memory
847	movel	4(%a2),%d2	|move word 2 to d2
848	movel	8(%a2),%d3	|move word 3 to d3
849	movew	(%a2),%d0		|move exp to d0
850	beqs	x_loop_fin	|if zero, skip the shift
851	subiw	#0x3ffd,%d0	|subtract off bias
852	negw	%d0		|make exp positive
853x_loop:
854	lsrl	#1,%d2		|shift d2:d3 right
855	roxrl	#1,%d3		|the number of places
856	dbf	%d0,x_loop	|given in d0
857x_loop_fin:
858	clrl	%d1		|put zero in d1 for addx
859	addil	#0x00000080,%d3	|inc at bit 6
860	addxl	%d1,%d2		|continue inc
861	andil	#0xffffff80,%d3	|strip off lsb not used by 882
862	movel	#4,%d0		|put 4 in d0 for binstr call
863	leal	L_SCR1(%a6),%a0	|a0 is ptr to L_SCR1 for exp digits
864	bsr	binstr		|call binstr to convert exp
865	movel	L_SCR1(%a6),%d0	|load L_SCR1 lword to d0
866	movel	#12,%d1		|use d1 for shift count
867	lsrl	%d1,%d0		|shift d0 right by 12
868	bfins	%d0,FP_SCR1(%a6){#4:#12} |put e3:e2:e1 in FP_SCR1
869	lsrl	%d1,%d0		|shift d0 right by 12
870	bfins	%d0,FP_SCR1(%a6){#16:#4} |put e4 in FP_SCR1
871	tstb	%d0		|check if e4 is zero
872	beqs	A16_st		|if zero, skip rest
873	orl	#opaop_mask,USER_FPSR(%a6) |set OPERR & AIOP in USER_FPSR
874
875
876| A16. Write sign bits to final string.
877|	   Sigma is bit 31 of initial value; RHO is bit 31 of d6 (ILOG).
878|
879| Register usage:
880|	Input/Output
881|	d0: x/scratch - final is x
882|	d2: x/x
883|	d3: x/x
884|	d4: LEN/Unchanged
885|	d5: ICTR:LAMBDA/LAMBDA:ICTR
886|	d6: ILOG/ILOG adjusted
887|	d7: k-factor/Unchanged
888|	a0: ptr to L_SCR1(a6)/Unchanged
889|	a1: ptr to PTENxx array/Unchanged
890|	a2: ptr to FP_SCR2(a6)/Unchanged
891|	fp0: float(ILOG)/Unchanged
892|	fp1: 10^ISCALE/Unchanged
893|	fp2: 10^LEN/Unchanged
894|	F_SCR1:BCD result with correct signs
895|	F_SCR2:ILOG/10^4
896|	L_SCR1:Exponent digits on return from binstr
897|	L_SCR2:first word of X packed/Unchanged
898
899A16_st:
900	clrl	%d0		|clr d0 for collection of signs
901	andib	#0x0f,FP_SCR1(%a6) |clear first nibble of FP_SCR1
902	tstl	L_SCR2(%a6)	|check sign of original mantissa
903	bges	mant_p		|if pos, don't set SM
904	moveql	#2,%d0		|move 2 in to d0 for SM
905mant_p:
906	tstl	%d6		|check sign of ILOG
907	bges	wr_sgn		|if pos, don't set SE
908	addql	#1,%d0		|set bit 0 in d0 for SE
909wr_sgn:
910	bfins	%d0,FP_SCR1(%a6){#0:#2} |insert SM and SE into FP_SCR1
911
912| Clean up and restore all registers used.
913
914	fmovel	#0,%FPSR		|clear possible inex2/ainex bits
915	fmovemx (%a7)+,%fp0-%fp2
916	moveml	(%a7)+,%d2-%d7/%a2
917	rts
918
919	|end
920