xref: /linux/arch/m68k/math-emu/fp_util.S (revision e5451c8f8330e03ad3cfa16048b4daf961af434f)
1/*
2 * fp_util.S
3 *
4 * Copyright Roman Zippel, 1997.  All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, and the entire permission notice in its entirety,
11 *    including the disclaimer of warranties.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote
16 *    products derived from this software without specific prior
17 *    written permission.
18 *
19 * ALTERNATIVELY, this product may be distributed under the terms of
20 * the GNU General Public License, in which case the provisions of the GPL are
21 * required INSTEAD OF the above restrictions.  (This clause is
22 * necessary due to a potential bad interaction between the GPL and
23 * the restrictions contained in a BSD-style copyright.)
24 *
25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
29 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
30 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
31 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
33 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
35 * OF THE POSSIBILITY OF SUCH DAMAGE.
36 */
37
38#include "fp_emu.h"
39
40/*
41 * Here are lots of conversion and normalization functions mainly
42 * used by fp_scan.S
43 * Note that these functions are optimized for "normal" numbers,
44 * these are handled first and exit as fast as possible, this is
45 * especially important for fp_normalize_ext/fp_conv_ext2ext, as
46 * it's called very often.
47 * The register usage is optimized for fp_scan.S and which register
48 * is currently at that time unused, be careful if you want change
49 * something here. %d0 and %d1 is always usable, sometimes %d2 (or
50 * only the lower half) most function have to return the %a0
51 * unmodified, so that the caller can immediately reuse it.
52 */
53
54	.globl	fp_ill, fp_end
55
56	| exits from fp_scan:
57	| illegal instruction
58fp_ill:
59	printf	,"fp_illegal\n"
60	rts
61	| completed instruction
62fp_end:
63	tst.l	(TASK_MM-8,%a2)
64	jmi	1f
65	tst.l	(TASK_MM-4,%a2)
66	jmi	1f
67	tst.l	(TASK_MM,%a2)
68	jpl	2f
691:	printf	,"oops:%p,%p,%p\n",3,%a2@(TASK_MM-8),%a2@(TASK_MM-4),%a2@(TASK_MM)
702:	clr.l	%d0
71	rts
72
73	.globl	fp_conv_long2ext, fp_conv_single2ext
74	.globl	fp_conv_double2ext, fp_conv_ext2ext
75	.globl	fp_normalize_ext, fp_normalize_double
76	.globl	fp_normalize_single, fp_normalize_single_fast
77	.globl	fp_conv_ext2double, fp_conv_ext2single
78	.globl	fp_conv_ext2long, fp_conv_ext2short
79	.globl	fp_conv_ext2byte
80	.globl	fp_finalrounding_single, fp_finalrounding_single_fast
81	.globl	fp_finalrounding_double
82	.globl	fp_finalrounding, fp_finaltest, fp_final
83
84/*
85 * First several conversion functions from a source operand
86 * into the extended format. Note, that only fp_conv_ext2ext
87 * normalizes the number and is always called after the other
88 * conversion functions, which only move the information into
89 * fp_ext structure.
90 */
91
92	| fp_conv_long2ext:
93	|
94	| args:	%d0 = source (32-bit long)
95	|	%a0 = destination (ptr to struct fp_ext)
96
97fp_conv_long2ext:
98	printf	PCONV,"l2e: %p -> %p(",2,%d0,%a0
99	clr.l	%d1			| sign defaults to zero
100	tst.l	%d0
101	jeq	fp_l2e_zero		| is source zero?
102	jpl	1f			| positive?
103	moveq	#1,%d1
104	neg.l	%d0
1051:	swap	%d1
106	move.w	#0x3fff+31,%d1
107	move.l	%d1,(%a0)+		| set sign / exp
108	move.l	%d0,(%a0)+		| set mantissa
109	clr.l	(%a0)
110	subq.l	#8,%a0			| restore %a0
111	printx	PCONV,%a0@
112	printf	PCONV,")\n"
113	rts
114	| source is zero
115fp_l2e_zero:
116	clr.l	(%a0)+
117	clr.l	(%a0)+
118	clr.l	(%a0)
119	subq.l	#8,%a0
120	printx	PCONV,%a0@
121	printf	PCONV,")\n"
122	rts
123
124	| fp_conv_single2ext
125	| args:	%d0 = source (single-precision fp value)
126	|	%a0 = dest (struct fp_ext *)
127
128fp_conv_single2ext:
129	printf	PCONV,"s2e: %p -> %p(",2,%d0,%a0
130	move.l	%d0,%d1
131	lsl.l	#8,%d0			| shift mantissa
132	lsr.l	#8,%d1			| exponent / sign
133	lsr.l	#7,%d1
134	lsr.w	#8,%d1
135	jeq	fp_s2e_small		| zero / denormal?
136	cmp.w	#0xff,%d1		| NaN / Inf?
137	jeq	fp_s2e_large
138	bset	#31,%d0			| set explizit bit
139	add.w	#0x3fff-0x7f,%d1	| re-bias the exponent.
1409:	move.l	%d1,(%a0)+		| fp_ext.sign, fp_ext.exp
141	move.l	%d0,(%a0)+		| high lword of fp_ext.mant
142	clr.l	(%a0)			| low lword = 0
143	subq.l	#8,%a0
144	printx	PCONV,%a0@
145	printf	PCONV,")\n"
146	rts
147	| zeros and denormalized
148fp_s2e_small:
149	| exponent is zero, so explizit bit is already zero too
150	tst.l	%d0
151	jeq	9b
152	move.w	#0x4000-0x7f,%d1
153	jra	9b
154	| infinities and NAN
155fp_s2e_large:
156	bclr	#31,%d0			| clear explizit bit
157	move.w	#0x7fff,%d1
158	jra	9b
159
160fp_conv_double2ext:
161#ifdef FPU_EMU_DEBUG
162	getuser.l %a1@(0),%d0,fp_err_ua2,%a1
163	getuser.l %a1@(4),%d1,fp_err_ua2,%a1
164	printf	PCONV,"d2e: %p%p -> %p(",3,%d0,%d1,%a0
165#endif
166	getuser.l (%a1)+,%d0,fp_err_ua2,%a1
167	move.l	%d0,%d1
168	lsl.l	#8,%d0			| shift high mantissa
169	lsl.l	#3,%d0
170	lsr.l	#8,%d1			| exponent / sign
171	lsr.l	#7,%d1
172	lsr.w	#5,%d1
173	jeq	fp_d2e_small		| zero / denormal?
174	cmp.w	#0x7ff,%d1		| NaN / Inf?
175	jeq	fp_d2e_large
176	bset	#31,%d0			| set explizit bit
177	add.w	#0x3fff-0x3ff,%d1	| re-bias the exponent.
1789:	move.l	%d1,(%a0)+		| fp_ext.sign, fp_ext.exp
179	move.l	%d0,(%a0)+
180	getuser.l (%a1)+,%d0,fp_err_ua2,%a1
181	move.l	%d0,%d1
182	lsl.l	#8,%d0
183	lsl.l	#3,%d0
184	move.l	%d0,(%a0)
185	moveq	#21,%d0
186	lsr.l	%d0,%d1
187	or.l	%d1,-(%a0)
188	subq.l	#4,%a0
189	printx	PCONV,%a0@
190	printf	PCONV,")\n"
191	rts
192	| zeros and denormalized
193fp_d2e_small:
194	| exponent is zero, so explizit bit is already zero too
195	tst.l	%d0
196	jeq	9b
197	move.w	#0x4000-0x3ff,%d1
198	jra	9b
199	| infinities and NAN
200fp_d2e_large:
201	bclr	#31,%d0			| clear explizit bit
202	move.w	#0x7fff,%d1
203	jra	9b
204
205	| fp_conv_ext2ext:
206	| originally used to get longdouble from userspace, now it's
207	| called before arithmetic operations to make sure the number
208	| is normalized [maybe rename it?].
209	| args:	%a0 = dest (struct fp_ext *)
210	| returns 0 in %d0 for a NaN, otherwise 1
211
212fp_conv_ext2ext:
213	printf	PCONV,"e2e: %p(",1,%a0
214	printx	PCONV,%a0@
215	printf	PCONV,"), "
216	move.l	(%a0)+,%d0
217	cmp.w	#0x7fff,%d0		| Inf / NaN?
218	jeq	fp_e2e_large
219	move.l	(%a0),%d0
220	jpl	fp_e2e_small		| zero / denorm?
221	| The high bit is set, so normalization is irrelevant.
222fp_e2e_checkround:
223	subq.l	#4,%a0
224#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
225	move.b	(%a0),%d0
226	jne	fp_e2e_round
227#endif
228	printf	PCONV,"%p(",1,%a0
229	printx	PCONV,%a0@
230	printf	PCONV,")\n"
231	moveq	#1,%d0
232	rts
233#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
234fp_e2e_round:
235	fp_set_sr FPSR_EXC_INEX2
236	clr.b	(%a0)
237	move.w	(FPD_RND,FPDATA),%d2
238	jne	fp_e2e_roundother	| %d2 == 0, round to nearest
239	tst.b	%d0			| test guard bit
240	jpl	9f			| zero is closer
241	btst	#0,(11,%a0)		| test lsb bit
242	jne	fp_e2e_doroundup	| round to infinity
243	lsl.b	#1,%d0			| check low bits
244	jeq	9f			| round to zero
245fp_e2e_doroundup:
246	addq.l	#1,(8,%a0)
247	jcc	9f
248	addq.l	#1,(4,%a0)
249	jcc	9f
250	move.w	#0x8000,(4,%a0)
251	addq.w	#1,(2,%a0)
2529:	printf	PNORM,"%p(",1,%a0
253	printx	PNORM,%a0@
254	printf	PNORM,")\n"
255	rts
256fp_e2e_roundother:
257	subq.w	#2,%d2
258	jcs	9b			| %d2 < 2, round to zero
259	jhi	1f			| %d2 > 2, round to +infinity
260	tst.b	(1,%a0)			| to -inf
261	jne	fp_e2e_doroundup	| negative, round to infinity
262	jra	9b			| positive, round to zero
2631:	tst.b	(1,%a0)			| to +inf
264	jeq	fp_e2e_doroundup	| positive, round to infinity
265	jra	9b			| negative, round to zero
266#endif
267	| zeros and subnormals:
268	| try to normalize these anyway.
269fp_e2e_small:
270	jne	fp_e2e_small1		| high lword zero?
271	move.l	(4,%a0),%d0
272	jne	fp_e2e_small2
273#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
274	clr.l	%d0
275	move.b	(-4,%a0),%d0
276	jne	fp_e2e_small3
277#endif
278	| Genuine zero.
279	clr.w	-(%a0)
280	subq.l	#2,%a0
281	printf	PNORM,"%p(",1,%a0
282	printx	PNORM,%a0@
283	printf	PNORM,")\n"
284	moveq	#1,%d0
285	rts
286	| definitely subnormal, need to shift all 64 bits
287fp_e2e_small1:
288	bfffo	%d0{#0,#32},%d1
289	move.w	-(%a0),%d2
290	sub.w	%d1,%d2
291	jcc	1f
292	| Pathologically small, denormalize.
293	add.w	%d2,%d1
294	clr.w	%d2
2951:	move.w	%d2,(%a0)+
296	move.w	%d1,%d2
297	jeq	fp_e2e_checkround
298	| fancy 64-bit double-shift begins here
299	lsl.l	%d2,%d0
300	move.l	%d0,(%a0)+
301	move.l	(%a0),%d0
302	move.l	%d0,%d1
303	lsl.l	%d2,%d0
304	move.l	%d0,(%a0)
305	neg.w	%d2
306	and.w	#0x1f,%d2
307	lsr.l	%d2,%d1
308	or.l	%d1,-(%a0)
309#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
310fp_e2e_extra1:
311	clr.l	%d0
312	move.b	(-4,%a0),%d0
313	neg.w	%d2
314	add.w	#24,%d2
315	jcc	1f
316	clr.b	(-4,%a0)
317	lsl.l	%d2,%d0
318	or.l	%d0,(4,%a0)
319	jra	fp_e2e_checkround
3201:	addq.w	#8,%d2
321	lsl.l	%d2,%d0
322	move.b	%d0,(-4,%a0)
323	lsr.l	#8,%d0
324	or.l	%d0,(4,%a0)
325#endif
326	jra	fp_e2e_checkround
327	| pathologically small subnormal
328fp_e2e_small2:
329	bfffo	%d0{#0,#32},%d1
330	add.w	#32,%d1
331	move.w	-(%a0),%d2
332	sub.w	%d1,%d2
333	jcc	1f
334	| Beyond pathologically small, denormalize.
335	add.w	%d2,%d1
336	clr.w	%d2
3371:	move.w	%d2,(%a0)+
338	ext.l	%d1
339	jeq	fp_e2e_checkround
340	clr.l	(4,%a0)
341	sub.w	#32,%d2
342	jcs	1f
343	lsl.l	%d1,%d0			| lower lword needs only to be shifted
344	move.l	%d0,(%a0)		| into the higher lword
345#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
346	clr.l	%d0
347	move.b	(-4,%a0),%d0
348	clr.b	(-4,%a0)
349	neg.w	%d1
350	add.w	#32,%d1
351	bfins	%d0,(%a0){%d1,#8}
352#endif
353	jra	fp_e2e_checkround
3541:	neg.w	%d1			| lower lword is splitted between
355	bfins	%d0,(%a0){%d1,#32}	| higher and lower lword
356#ifndef CONFIG_M68KFPU_EMU_EXTRAPREC
357	jra	fp_e2e_checkround
358#else
359	move.w	%d1,%d2
360	jra	fp_e2e_extra1
361	| These are extremely small numbers, that will mostly end up as zero
362	| anyway, so this is only important for correct rounding.
363fp_e2e_small3:
364	bfffo	%d0{#24,#8},%d1
365	add.w	#40,%d1
366	move.w	-(%a0),%d2
367	sub.w	%d1,%d2
368	jcc	1f
369	| Pathologically small, denormalize.
370	add.w	%d2,%d1
371	clr.w	%d2
3721:	move.w	%d2,(%a0)+
373	ext.l	%d1
374	jeq	fp_e2e_checkround
375	cmp.w	#8,%d1
376	jcs	2f
3771:	clr.b	(-4,%a0)
378	sub.w	#64,%d1
379	jcs	1f
380	add.w	#24,%d1
381	lsl.l	%d1,%d0
382	move.l	%d0,(%a0)
383	jra	fp_e2e_checkround
3841:	neg.w	%d1
385	bfins	%d0,(%a0){%d1,#8}
386	jra	fp_e2e_checkround
3872:	lsl.l	%d1,%d0
388	move.b	%d0,(-4,%a0)
389	lsr.l	#8,%d0
390	move.b	%d0,(7,%a0)
391	jra	fp_e2e_checkround
392#endif
3931:	move.l	%d0,%d1			| lower lword is splitted between
394	lsl.l	%d2,%d0			| higher and lower lword
395	move.l	%d0,(%a0)
396	move.l	%d1,%d0
397	neg.w	%d2
398	add.w	#32,%d2
399	lsr.l	%d2,%d0
400	move.l	%d0,-(%a0)
401	jra	fp_e2e_checkround
402	| Infinities and NaNs
403fp_e2e_large:
404	move.l	(%a0)+,%d0
405	jne	3f
4061:	tst.l	(%a0)
407	jne	4f
408	moveq	#1,%d0
4092:	subq.l	#8,%a0
410	printf	PCONV,"%p(",1,%a0
411	printx	PCONV,%a0@
412	printf	PCONV,")\n"
413	rts
414	| we have maybe a NaN, shift off the highest bit
4153:	lsl.l	#1,%d0
416	jeq	1b
417	| we have a NaN, clear the return value
4184:	clrl	%d0
419	jra	2b
420
421
422/*
423 * Normalization functions.  Call these on the output of general
424 * FP operators, and before any conversion into the destination
425 * formats. fp_normalize_ext has always to be called first, the
426 * following conversion functions expect an already normalized
427 * number.
428 */
429
430	| fp_normalize_ext:
431	| normalize an extended in extended (unpacked) format, basically
432	| it does the same as fp_conv_ext2ext, additionally it also does
433	| the necessary postprocessing checks.
434	| args:	%a0 (struct fp_ext *)
435	| NOTE: it does _not_ modify %a0/%a1 and the upper word of %d2
436
437fp_normalize_ext:
438	printf	PNORM,"ne: %p(",1,%a0
439	printx	PNORM,%a0@
440	printf	PNORM,"), "
441	move.l	(%a0)+,%d0
442	cmp.w	#0x7fff,%d0		| Inf / NaN?
443	jeq	fp_ne_large
444	move.l	(%a0),%d0
445	jpl	fp_ne_small		| zero / denorm?
446	| The high bit is set, so normalization is irrelevant.
447fp_ne_checkround:
448	subq.l	#4,%a0
449#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
450	move.b	(%a0),%d0
451	jne	fp_ne_round
452#endif
453	printf	PNORM,"%p(",1,%a0
454	printx	PNORM,%a0@
455	printf	PNORM,")\n"
456	rts
457#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
458fp_ne_round:
459	fp_set_sr FPSR_EXC_INEX2
460	clr.b	(%a0)
461	move.w	(FPD_RND,FPDATA),%d2
462	jne	fp_ne_roundother	| %d2 == 0, round to nearest
463	tst.b	%d0			| test guard bit
464	jpl	9f			| zero is closer
465	btst	#0,(11,%a0)		| test lsb bit
466	jne	fp_ne_doroundup		| round to infinity
467	lsl.b	#1,%d0			| check low bits
468	jeq	9f			| round to zero
469fp_ne_doroundup:
470	addq.l	#1,(8,%a0)
471	jcc	9f
472	addq.l	#1,(4,%a0)
473	jcc	9f
474	addq.w	#1,(2,%a0)
475	move.w	#0x8000,(4,%a0)
4769:	printf	PNORM,"%p(",1,%a0
477	printx	PNORM,%a0@
478	printf	PNORM,")\n"
479	rts
480fp_ne_roundother:
481	subq.w	#2,%d2
482	jcs	9b			| %d2 < 2, round to zero
483	jhi	1f			| %d2 > 2, round to +infinity
484	tst.b	(1,%a0)			| to -inf
485	jne	fp_ne_doroundup		| negative, round to infinity
486	jra	9b			| positive, round to zero
4871:	tst.b	(1,%a0)			| to +inf
488	jeq	fp_ne_doroundup		| positive, round to infinity
489	jra	9b			| negative, round to zero
490#endif
491	| Zeros and subnormal numbers
492	| These are probably merely subnormal, rather than "denormalized"
493	|  numbers, so we will try to make them normal again.
494fp_ne_small:
495	jne	fp_ne_small1		| high lword zero?
496	move.l	(4,%a0),%d0
497	jne	fp_ne_small2
498#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
499	clr.l	%d0
500	move.b	(-4,%a0),%d0
501	jne	fp_ne_small3
502#endif
503	| Genuine zero.
504	clr.w	-(%a0)
505	subq.l	#2,%a0
506	printf	PNORM,"%p(",1,%a0
507	printx	PNORM,%a0@
508	printf	PNORM,")\n"
509	rts
510	| Subnormal.
511fp_ne_small1:
512	bfffo	%d0{#0,#32},%d1
513	move.w	-(%a0),%d2
514	sub.w	%d1,%d2
515	jcc	1f
516	| Pathologically small, denormalize.
517	add.w	%d2,%d1
518	clr.w	%d2
519	fp_set_sr FPSR_EXC_UNFL
5201:	move.w	%d2,(%a0)+
521	move.w	%d1,%d2
522	jeq	fp_ne_checkround
523	| This is exactly the same 64-bit double shift as seen above.
524	lsl.l	%d2,%d0
525	move.l	%d0,(%a0)+
526	move.l	(%a0),%d0
527	move.l	%d0,%d1
528	lsl.l	%d2,%d0
529	move.l	%d0,(%a0)
530	neg.w	%d2
531	and.w	#0x1f,%d2
532	lsr.l	%d2,%d1
533	or.l	%d1,-(%a0)
534#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
535fp_ne_extra1:
536	clr.l	%d0
537	move.b	(-4,%a0),%d0
538	neg.w	%d2
539	add.w	#24,%d2
540	jcc	1f
541	clr.b	(-4,%a0)
542	lsl.l	%d2,%d0
543	or.l	%d0,(4,%a0)
544	jra	fp_ne_checkround
5451:	addq.w	#8,%d2
546	lsl.l	%d2,%d0
547	move.b	%d0,(-4,%a0)
548	lsr.l	#8,%d0
549	or.l	%d0,(4,%a0)
550#endif
551	jra	fp_ne_checkround
552	| May or may not be subnormal, if so, only 32 bits to shift.
553fp_ne_small2:
554	bfffo	%d0{#0,#32},%d1
555	add.w	#32,%d1
556	move.w	-(%a0),%d2
557	sub.w	%d1,%d2
558	jcc	1f
559	| Beyond pathologically small, denormalize.
560	add.w	%d2,%d1
561	clr.w	%d2
562	fp_set_sr FPSR_EXC_UNFL
5631:	move.w	%d2,(%a0)+
564	ext.l	%d1
565	jeq	fp_ne_checkround
566	clr.l	(4,%a0)
567	sub.w	#32,%d1
568	jcs	1f
569	lsl.l	%d1,%d0			| lower lword needs only to be shifted
570	move.l	%d0,(%a0)		| into the higher lword
571#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
572	clr.l	%d0
573	move.b	(-4,%a0),%d0
574	clr.b	(-4,%a0)
575	neg.w	%d1
576	add.w	#32,%d1
577	bfins	%d0,(%a0){%d1,#8}
578#endif
579	jra	fp_ne_checkround
5801:	neg.w	%d1			| lower lword is splitted between
581	bfins	%d0,(%a0){%d1,#32}	| higher and lower lword
582#ifndef CONFIG_M68KFPU_EMU_EXTRAPREC
583	jra	fp_ne_checkround
584#else
585	move.w	%d1,%d2
586	jra	fp_ne_extra1
587	| These are extremely small numbers, that will mostly end up as zero
588	| anyway, so this is only important for correct rounding.
589fp_ne_small3:
590	bfffo	%d0{#24,#8},%d1
591	add.w	#40,%d1
592	move.w	-(%a0),%d2
593	sub.w	%d1,%d2
594	jcc	1f
595	| Pathologically small, denormalize.
596	add.w	%d2,%d1
597	clr.w	%d2
5981:	move.w	%d2,(%a0)+
599	ext.l	%d1
600	jeq	fp_ne_checkround
601	cmp.w	#8,%d1
602	jcs	2f
6031:	clr.b	(-4,%a0)
604	sub.w	#64,%d1
605	jcs	1f
606	add.w	#24,%d1
607	lsl.l	%d1,%d0
608	move.l	%d0,(%a0)
609	jra	fp_ne_checkround
6101:	neg.w	%d1
611	bfins	%d0,(%a0){%d1,#8}
612	jra	fp_ne_checkround
6132:	lsl.l	%d1,%d0
614	move.b	%d0,(-4,%a0)
615	lsr.l	#8,%d0
616	move.b	%d0,(7,%a0)
617	jra	fp_ne_checkround
618#endif
619	| Infinities and NaNs, again, same as above.
620fp_ne_large:
621	move.l	(%a0)+,%d0
622	jne	3f
6231:	tst.l	(%a0)
624	jne	4f
6252:	subq.l	#8,%a0
626	printf	PNORM,"%p(",1,%a0
627	printx	PNORM,%a0@
628	printf	PNORM,")\n"
629	rts
630	| we have maybe a NaN, shift off the highest bit
6313:	move.l	%d0,%d1
632	lsl.l	#1,%d1
633	jne	4f
634	clr.l	(-4,%a0)
635	jra	1b
636	| we have a NaN, test if it is signaling
6374:	bset	#30,%d0
638	jne	2b
639	fp_set_sr FPSR_EXC_SNAN
640	move.l	%d0,(-4,%a0)
641	jra	2b
642
643	| these next two do rounding as per the IEEE standard.
644	| values for the rounding modes appear to be:
645	| 0:	Round to nearest
646	| 1:	Round to zero
647	| 2:	Round to -Infinity
648	| 3:	Round to +Infinity
649	| both functions expect that fp_normalize was already
650	| called (and extended argument is already normalized
651	| as far as possible), these are used if there is different
652	| rounding precision is selected and before converting
653	| into single/double
654
655	| fp_normalize_double:
656	| normalize an extended with double (52-bit) precision
657	| args:	 %a0 (struct fp_ext *)
658
659fp_normalize_double:
660	printf	PNORM,"nd: %p(",1,%a0
661	printx	PNORM,%a0@
662	printf	PNORM,"), "
663	move.l	(%a0)+,%d2
664	tst.w	%d2
665	jeq	fp_nd_zero		| zero / denormalized
666	cmp.w	#0x7fff,%d2
667	jeq	fp_nd_huge		| NaN / infinitive.
668	sub.w	#0x4000-0x3ff,%d2	| will the exponent fit?
669	jcs	fp_nd_small		| too small.
670	cmp.w	#0x7fe,%d2
671	jcc	fp_nd_large		| too big.
672	addq.l	#4,%a0
673	move.l	(%a0),%d0		| low lword of mantissa
674	| now, round off the low 11 bits.
675fp_nd_round:
676	moveq	#21,%d1
677	lsl.l	%d1,%d0			| keep 11 low bits.
678	jne	fp_nd_checkround	| Are they non-zero?
679	| nothing to do here
6809:	subq.l	#8,%a0
681	printf	PNORM,"%p(",1,%a0
682	printx	PNORM,%a0@
683	printf	PNORM,")\n"
684	rts
685	| Be careful with the X bit! It contains the lsb
686	| from the shift above, it is needed for round to nearest.
687fp_nd_checkround:
688	fp_set_sr FPSR_EXC_INEX2	| INEX2 bit
689	and.w	#0xf800,(2,%a0)		| clear bits 0-10
690	move.w	(FPD_RND,FPDATA),%d2	| rounding mode
691	jne	2f			| %d2 == 0, round to nearest
692	tst.l	%d0			| test guard bit
693	jpl	9b			| zero is closer
694	| here we test the X bit by adding it to %d2
695	clr.w	%d2			| first set z bit, addx only clears it
696	addx.w	%d2,%d2			| test lsb bit
697	| IEEE754-specified "round to even" behaviour.  If the guard
698	| bit is set, then the number is odd, so rounding works like
699	| in grade-school arithmetic (i.e. 1.5 rounds to 2.0)
700	| Otherwise, an equal distance rounds towards zero, so as not
701	| to produce an odd number.  This is strange, but it is what
702	| the standard says.
703	jne	fp_nd_doroundup		| round to infinity
704	lsl.l	#1,%d0			| check low bits
705	jeq	9b			| round to zero
706fp_nd_doroundup:
707	| round (the mantissa, that is) towards infinity
708	add.l	#0x800,(%a0)
709	jcc	9b			| no overflow, good.
710	addq.l	#1,-(%a0)		| extend to high lword
711	jcc	1f			| no overflow, good.
712	| Yow! we have managed to overflow the mantissa.  Since this
713	| only happens when %d1 was 0xfffff800, it is now zero, so
714	| reset the high bit, and increment the exponent.
715	move.w	#0x8000,(%a0)
716	addq.w	#1,-(%a0)
717	cmp.w	#0x43ff,(%a0)+		| exponent now overflown?
718	jeq	fp_nd_large		| yes, so make it infinity.
7191:	subq.l	#4,%a0
720	printf	PNORM,"%p(",1,%a0
721	printx	PNORM,%a0@
722	printf	PNORM,")\n"
723	rts
7242:	subq.w	#2,%d2
725	jcs	9b			| %d2 < 2, round to zero
726	jhi	3f			| %d2 > 2, round to +infinity
727	| Round to +Inf or -Inf.  High word of %d2 contains the
728	| sign of the number, by the way.
729	swap	%d2			| to -inf
730	tst.b	%d2
731	jne	fp_nd_doroundup		| negative, round to infinity
732	jra	9b			| positive, round to zero
7333:	swap	%d2			| to +inf
734	tst.b	%d2
735	jeq	fp_nd_doroundup		| positive, round to infinity
736	jra	9b			| negative, round to zero
737	| Exponent underflow.  Try to make a denormal, and set it to
738	| the smallest possible fraction if this fails.
739fp_nd_small:
740	fp_set_sr FPSR_EXC_UNFL		| set UNFL bit
741	move.w	#0x3c01,(-2,%a0)	| 2**-1022
742	neg.w	%d2			| degree of underflow
743	cmp.w	#32,%d2			| single or double shift?
744	jcc	1f
745	| Again, another 64-bit double shift.
746	move.l	(%a0),%d0
747	move.l	%d0,%d1
748	lsr.l	%d2,%d0
749	move.l	%d0,(%a0)+
750	move.l	(%a0),%d0
751	lsr.l	%d2,%d0
752	neg.w	%d2
753	add.w	#32,%d2
754	lsl.l	%d2,%d1
755	or.l	%d1,%d0
756	move.l	(%a0),%d1
757	move.l	%d0,(%a0)
758	| Check to see if we shifted off any significant bits
759	lsl.l	%d2,%d1
760	jeq	fp_nd_round		| Nope, round.
761	bset	#0,%d0			| Yes, so set the "sticky bit".
762	jra	fp_nd_round		| Now, round.
763	| Another 64-bit single shift and store
7641:	sub.w	#32,%d2
765	cmp.w	#32,%d2			| Do we really need to shift?
766	jcc	2f			| No, the number is too small.
767	move.l	(%a0),%d0
768	clr.l	(%a0)+
769	move.l	%d0,%d1
770	lsr.l	%d2,%d0
771	neg.w	%d2
772	add.w	#32,%d2
773	| Again, check to see if we shifted off any significant bits.
774	tst.l	(%a0)
775	jeq	1f
776	bset	#0,%d0			| Sticky bit.
7771:	move.l	%d0,(%a0)
778	lsl.l	%d2,%d1
779	jeq	fp_nd_round
780	bset	#0,%d0
781	jra	fp_nd_round
782	| Sorry, the number is just too small.
7832:	clr.l	(%a0)+
784	clr.l	(%a0)
785	moveq	#1,%d0			| Smallest possible fraction,
786	jra	fp_nd_round		| round as desired.
787	| zero and denormalized
788fp_nd_zero:
789	tst.l	(%a0)+
790	jne	1f
791	tst.l	(%a0)
792	jne	1f
793	subq.l	#8,%a0
794	printf	PNORM,"%p(",1,%a0
795	printx	PNORM,%a0@
796	printf	PNORM,")\n"
797	rts				| zero.  nothing to do.
798	| These are not merely subnormal numbers, but true denormals,
799	| i.e. pathologically small (exponent is 2**-16383) numbers.
800	| It is clearly impossible for even a normal extended number
801	| with that exponent to fit into double precision, so just
802	| write these ones off as "too darn small".
8031:	fp_set_sr FPSR_EXC_UNFL		| Set UNFL bit
804	clr.l	(%a0)
805	clr.l	-(%a0)
806	move.w	#0x3c01,-(%a0)		| i.e. 2**-1022
807	addq.l	#6,%a0
808	moveq	#1,%d0
809	jra	fp_nd_round		| round.
810	| Exponent overflow.  Just call it infinity.
811fp_nd_large:
812	move.w	#0x7ff,%d0
813	and.w	(6,%a0),%d0
814	jeq	1f
815	fp_set_sr FPSR_EXC_INEX2
8161:	fp_set_sr FPSR_EXC_OVFL
817	move.w	(FPD_RND,FPDATA),%d2
818	jne	3f			| %d2 = 0 round to nearest
8191:	move.w	#0x7fff,(-2,%a0)
820	clr.l	(%a0)+
821	clr.l	(%a0)
8222:	subq.l	#8,%a0
823	printf	PNORM,"%p(",1,%a0
824	printx	PNORM,%a0@
825	printf	PNORM,")\n"
826	rts
8273:	subq.w	#2,%d2
828	jcs	5f			| %d2 < 2, round to zero
829	jhi	4f			| %d2 > 2, round to +infinity
830	tst.b	(-3,%a0)		| to -inf
831	jne	1b
832	jra	5f
8334:	tst.b	(-3,%a0)		| to +inf
834	jeq	1b
8355:	move.w	#0x43fe,(-2,%a0)
836	moveq	#-1,%d0
837	move.l	%d0,(%a0)+
838	move.w	#0xf800,%d0
839	move.l	%d0,(%a0)
840	jra	2b
841	| Infinities or NaNs
842fp_nd_huge:
843	subq.l	#4,%a0
844	printf	PNORM,"%p(",1,%a0
845	printx	PNORM,%a0@
846	printf	PNORM,")\n"
847	rts
848
849	| fp_normalize_single:
850	| normalize an extended with single (23-bit) precision
851	| args:	 %a0 (struct fp_ext *)
852
853fp_normalize_single:
854	printf	PNORM,"ns: %p(",1,%a0
855	printx	PNORM,%a0@
856	printf	PNORM,") "
857	addq.l	#2,%a0
858	move.w	(%a0)+,%d2
859	jeq	fp_ns_zero		| zero / denormalized
860	cmp.w	#0x7fff,%d2
861	jeq	fp_ns_huge		| NaN / infinitive.
862	sub.w	#0x4000-0x7f,%d2	| will the exponent fit?
863	jcs	fp_ns_small		| too small.
864	cmp.w	#0xfe,%d2
865	jcc	fp_ns_large		| too big.
866	move.l	(%a0)+,%d0		| get high lword of mantissa
867fp_ns_round:
868	tst.l	(%a0)			| check the low lword
869	jeq	1f
870	| Set a sticky bit if it is non-zero.  This should only
871	| affect the rounding in what would otherwise be equal-
872	| distance situations, which is what we want it to do.
873	bset	#0,%d0
8741:	clr.l	(%a0)			| zap it from memory.
875	| now, round off the low 8 bits of the hi lword.
876	tst.b	%d0			| 8 low bits.
877	jne	fp_ns_checkround	| Are they non-zero?
878	| nothing to do here
879	subq.l	#8,%a0
880	printf	PNORM,"%p(",1,%a0
881	printx	PNORM,%a0@
882	printf	PNORM,")\n"
883	rts
884fp_ns_checkround:
885	fp_set_sr FPSR_EXC_INEX2	| INEX2 bit
886	clr.b	-(%a0)			| clear low byte of high lword
887	subq.l	#3,%a0
888	move.w	(FPD_RND,FPDATA),%d2	| rounding mode
889	jne	2f			| %d2 == 0, round to nearest
890	tst.b	%d0			| test guard bit
891	jpl	9f			| zero is closer
892	btst	#8,%d0			| test lsb bit
893	| round to even behaviour, see above.
894	jne	fp_ns_doroundup		| round to infinity
895	lsl.b	#1,%d0			| check low bits
896	jeq	9f			| round to zero
897fp_ns_doroundup:
898	| round (the mantissa, that is) towards infinity
899	add.l	#0x100,(%a0)
900	jcc	9f			| no overflow, good.
901	| Overflow.  This means that the %d1 was 0xffffff00, so it
902	| is now zero.  We will set the mantissa to reflect this, and
903	| increment the exponent (checking for overflow there too)
904	move.w	#0x8000,(%a0)
905	addq.w	#1,-(%a0)
906	cmp.w	#0x407f,(%a0)+		| exponent now overflown?
907	jeq	fp_ns_large		| yes, so make it infinity.
9089:	subq.l	#4,%a0
909	printf	PNORM,"%p(",1,%a0
910	printx	PNORM,%a0@
911	printf	PNORM,")\n"
912	rts
913	| check nondefault rounding modes
9142:	subq.w	#2,%d2
915	jcs	9b			| %d2 < 2, round to zero
916	jhi	3f			| %d2 > 2, round to +infinity
917	tst.b	(-3,%a0)		| to -inf
918	jne	fp_ns_doroundup		| negative, round to infinity
919	jra	9b			| positive, round to zero
9203:	tst.b	(-3,%a0)		| to +inf
921	jeq	fp_ns_doroundup		| positive, round to infinity
922	jra	9b			| negative, round to zero
923	| Exponent underflow.  Try to make a denormal, and set it to
924	| the smallest possible fraction if this fails.
925fp_ns_small:
926	fp_set_sr FPSR_EXC_UNFL		| set UNFL bit
927	move.w	#0x3f81,(-2,%a0)	| 2**-126
928	neg.w	%d2			| degree of underflow
929	cmp.w	#32,%d2			| single or double shift?
930	jcc	2f
931	| a 32-bit shift.
932	move.l	(%a0),%d0
933	move.l	%d0,%d1
934	lsr.l	%d2,%d0
935	move.l	%d0,(%a0)+
936	| Check to see if we shifted off any significant bits.
937	neg.w	%d2
938	add.w	#32,%d2
939	lsl.l	%d2,%d1
940	jeq	1f
941	bset	#0,%d0			| Sticky bit.
942	| Check the lower lword
9431:	tst.l	(%a0)
944	jeq	fp_ns_round
945	clr	(%a0)
946	bset	#0,%d0			| Sticky bit.
947	jra	fp_ns_round
948	| Sorry, the number is just too small.
9492:	clr.l	(%a0)+
950	clr.l	(%a0)
951	moveq	#1,%d0			| Smallest possible fraction,
952	jra	fp_ns_round		| round as desired.
953	| Exponent overflow.  Just call it infinity.
954fp_ns_large:
955	tst.b	(3,%a0)
956	jeq	1f
957	fp_set_sr FPSR_EXC_INEX2
9581:	fp_set_sr FPSR_EXC_OVFL
959	move.w	(FPD_RND,FPDATA),%d2
960	jne	3f			| %d2 = 0 round to nearest
9611:	move.w	#0x7fff,(-2,%a0)
962	clr.l	(%a0)+
963	clr.l	(%a0)
9642:	subq.l	#8,%a0
965	printf	PNORM,"%p(",1,%a0
966	printx	PNORM,%a0@
967	printf	PNORM,")\n"
968	rts
9693:	subq.w	#2,%d2
970	jcs	5f			| %d2 < 2, round to zero
971	jhi	4f			| %d2 > 2, round to +infinity
972	tst.b	(-3,%a0)		| to -inf
973	jne	1b
974	jra	5f
9754:	tst.b	(-3,%a0)		| to +inf
976	jeq	1b
9775:	move.w	#0x407e,(-2,%a0)
978	move.l	#0xffffff00,(%a0)+
979	clr.l	(%a0)
980	jra	2b
981	| zero and denormalized
982fp_ns_zero:
983	tst.l	(%a0)+
984	jne	1f
985	tst.l	(%a0)
986	jne	1f
987	subq.l	#8,%a0
988	printf	PNORM,"%p(",1,%a0
989	printx	PNORM,%a0@
990	printf	PNORM,")\n"
991	rts				| zero.  nothing to do.
992	| These are not merely subnormal numbers, but true denormals,
993	| i.e. pathologically small (exponent is 2**-16383) numbers.
994	| It is clearly impossible for even a normal extended number
995	| with that exponent to fit into single precision, so just
996	| write these ones off as "too darn small".
9971:	fp_set_sr FPSR_EXC_UNFL		| Set UNFL bit
998	clr.l	(%a0)
999	clr.l	-(%a0)
1000	move.w	#0x3f81,-(%a0)		| i.e. 2**-126
1001	addq.l	#6,%a0
1002	moveq	#1,%d0
1003	jra	fp_ns_round		| round.
1004	| Infinities or NaNs
1005fp_ns_huge:
1006	subq.l	#4,%a0
1007	printf	PNORM,"%p(",1,%a0
1008	printx	PNORM,%a0@
1009	printf	PNORM,")\n"
1010	rts
1011
1012	| fp_normalize_single_fast:
1013	| normalize an extended with single (23-bit) precision
1014	| this is only used by fsgldiv/fsgdlmul, where the
1015	| operand is not completly normalized.
1016	| args:	 %a0 (struct fp_ext *)
1017
1018fp_normalize_single_fast:
1019	printf	PNORM,"nsf: %p(",1,%a0
1020	printx	PNORM,%a0@
1021	printf	PNORM,") "
1022	addq.l	#2,%a0
1023	move.w	(%a0)+,%d2
1024	cmp.w	#0x7fff,%d2
1025	jeq	fp_nsf_huge		| NaN / infinitive.
1026	move.l	(%a0)+,%d0		| get high lword of mantissa
1027fp_nsf_round:
1028	tst.l	(%a0)			| check the low lword
1029	jeq	1f
1030	| Set a sticky bit if it is non-zero.  This should only
1031	| affect the rounding in what would otherwise be equal-
1032	| distance situations, which is what we want it to do.
1033	bset	#0,%d0
10341:	clr.l	(%a0)			| zap it from memory.
1035	| now, round off the low 8 bits of the hi lword.
1036	tst.b	%d0			| 8 low bits.
1037	jne	fp_nsf_checkround	| Are they non-zero?
1038	| nothing to do here
1039	subq.l	#8,%a0
1040	printf	PNORM,"%p(",1,%a0
1041	printx	PNORM,%a0@
1042	printf	PNORM,")\n"
1043	rts
1044fp_nsf_checkround:
1045	fp_set_sr FPSR_EXC_INEX2	| INEX2 bit
1046	clr.b	-(%a0)			| clear low byte of high lword
1047	subq.l	#3,%a0
1048	move.w	(FPD_RND,FPDATA),%d2	| rounding mode
1049	jne	2f			| %d2 == 0, round to nearest
1050	tst.b	%d0			| test guard bit
1051	jpl	9f			| zero is closer
1052	btst	#8,%d0			| test lsb bit
1053	| round to even behaviour, see above.
1054	jne	fp_nsf_doroundup		| round to infinity
1055	lsl.b	#1,%d0			| check low bits
1056	jeq	9f			| round to zero
1057fp_nsf_doroundup:
1058	| round (the mantissa, that is) towards infinity
1059	add.l	#0x100,(%a0)
1060	jcc	9f			| no overflow, good.
1061	| Overflow.  This means that the %d1 was 0xffffff00, so it
1062	| is now zero.  We will set the mantissa to reflect this, and
1063	| increment the exponent (checking for overflow there too)
1064	move.w	#0x8000,(%a0)
1065	addq.w	#1,-(%a0)
1066	cmp.w	#0x407f,(%a0)+		| exponent now overflown?
1067	jeq	fp_nsf_large		| yes, so make it infinity.
10689:	subq.l	#4,%a0
1069	printf	PNORM,"%p(",1,%a0
1070	printx	PNORM,%a0@
1071	printf	PNORM,")\n"
1072	rts
1073	| check nondefault rounding modes
10742:	subq.w	#2,%d2
1075	jcs	9b			| %d2 < 2, round to zero
1076	jhi	3f			| %d2 > 2, round to +infinity
1077	tst.b	(-3,%a0)		| to -inf
1078	jne	fp_nsf_doroundup	| negative, round to infinity
1079	jra	9b			| positive, round to zero
10803:	tst.b	(-3,%a0)		| to +inf
1081	jeq	fp_nsf_doroundup		| positive, round to infinity
1082	jra	9b			| negative, round to zero
1083	| Exponent overflow.  Just call it infinity.
1084fp_nsf_large:
1085	tst.b	(3,%a0)
1086	jeq	1f
1087	fp_set_sr FPSR_EXC_INEX2
10881:	fp_set_sr FPSR_EXC_OVFL
1089	move.w	(FPD_RND,FPDATA),%d2
1090	jne	3f			| %d2 = 0 round to nearest
10911:	move.w	#0x7fff,(-2,%a0)
1092	clr.l	(%a0)+
1093	clr.l	(%a0)
10942:	subq.l	#8,%a0
1095	printf	PNORM,"%p(",1,%a0
1096	printx	PNORM,%a0@
1097	printf	PNORM,")\n"
1098	rts
10993:	subq.w	#2,%d2
1100	jcs	5f			| %d2 < 2, round to zero
1101	jhi	4f			| %d2 > 2, round to +infinity
1102	tst.b	(-3,%a0)		| to -inf
1103	jne	1b
1104	jra	5f
11054:	tst.b	(-3,%a0)		| to +inf
1106	jeq	1b
11075:	move.w	#0x407e,(-2,%a0)
1108	move.l	#0xffffff00,(%a0)+
1109	clr.l	(%a0)
1110	jra	2b
1111	| Infinities or NaNs
1112fp_nsf_huge:
1113	subq.l	#4,%a0
1114	printf	PNORM,"%p(",1,%a0
1115	printx	PNORM,%a0@
1116	printf	PNORM,")\n"
1117	rts
1118
1119	| conv_ext2int (macro):
1120	| Generates a subroutine that converts an extended value to an
1121	| integer of a given size, again, with the appropriate type of
1122	| rounding.
1123
1124	| Macro arguments:
1125	| s:	size, as given in an assembly instruction.
1126	| b:	number of bits in that size.
1127
1128	| Subroutine arguments:
1129	| %a0:	source (struct fp_ext *)
1130
1131	| Returns the integer in %d0 (like it should)
1132
1133.macro conv_ext2int s,b
1134	.set	inf,(1<<(\b-1))-1	| i.e. MAXINT
1135	printf	PCONV,"e2i%d: %p(",2,#\b,%a0
1136	printx	PCONV,%a0@
1137	printf	PCONV,") "
1138	addq.l	#2,%a0
1139	move.w	(%a0)+,%d2		| exponent
1140	jeq	fp_e2i_zero\b		| zero / denorm (== 0, here)
1141	cmp.w	#0x7fff,%d2
1142	jeq	fp_e2i_huge\b		| Inf / NaN
1143	sub.w	#0x3ffe,%d2
1144	jcs	fp_e2i_small\b
1145	cmp.w	#\b,%d2
1146	jhi	fp_e2i_large\b
1147	move.l	(%a0),%d0
1148	move.l	%d0,%d1
1149	lsl.l	%d2,%d1
1150	jne	fp_e2i_round\b
1151	tst.l	(4,%a0)
1152	jne	fp_e2i_round\b
1153	neg.w	%d2
1154	add.w	#32,%d2
1155	lsr.l	%d2,%d0
11569:	tst.w	(-4,%a0)
1157	jne	1f
1158	tst.\s	%d0
1159	jmi	fp_e2i_large\b
1160	printf	PCONV,"-> %p\n",1,%d0
1161	rts
11621:	neg.\s	%d0
1163	jeq	1f
1164	jpl	fp_e2i_large\b
11651:	printf	PCONV,"-> %p\n",1,%d0
1166	rts
1167fp_e2i_round\b:
1168	fp_set_sr FPSR_EXC_INEX2	| INEX2 bit
1169	neg.w	%d2
1170	add.w	#32,%d2
1171	.if	\b>16
1172	jeq	5f
1173	.endif
1174	lsr.l	%d2,%d0
1175	move.w	(FPD_RND,FPDATA),%d2	| rounding mode
1176	jne	2f			| %d2 == 0, round to nearest
1177	tst.l	%d1			| test guard bit
1178	jpl	9b			| zero is closer
1179	btst	%d2,%d0			| test lsb bit (%d2 still 0)
1180	jne	fp_e2i_doroundup\b
1181	lsl.l	#1,%d1			| check low bits
1182	jne	fp_e2i_doroundup\b
1183	tst.l	(4,%a0)
1184	jeq	9b
1185fp_e2i_doroundup\b:
1186	addq.l	#1,%d0
1187	jra	9b
1188	| check nondefault rounding modes
11892:	subq.w	#2,%d2
1190	jcs	9b			| %d2 < 2, round to zero
1191	jhi	3f			| %d2 > 2, round to +infinity
1192	tst.w	(-4,%a0)		| to -inf
1193	jne	fp_e2i_doroundup\b	| negative, round to infinity
1194	jra	9b			| positive, round to zero
11953:	tst.w	(-4,%a0)		| to +inf
1196	jeq	fp_e2i_doroundup\b	| positive, round to infinity
1197	jra	9b	| negative, round to zero
1198	| we are only want -2**127 get correctly rounded here,
1199	| since the guard bit is in the lower lword.
1200	| everything else ends up anyway as overflow.
1201	.if	\b>16
12025:	move.w	(FPD_RND,FPDATA),%d2	| rounding mode
1203	jne	2b			| %d2 == 0, round to nearest
1204	move.l	(4,%a0),%d1		| test guard bit
1205	jpl	9b			| zero is closer
1206	lsl.l	#1,%d1			| check low bits
1207	jne	fp_e2i_doroundup\b
1208	jra	9b
1209	.endif
1210fp_e2i_zero\b:
1211	clr.l	%d0
1212	tst.l	(%a0)+
1213	jne	1f
1214	tst.l	(%a0)
1215	jeq	3f
12161:	subq.l	#4,%a0
1217	fp_clr_sr FPSR_EXC_UNFL		| fp_normalize_ext has set this bit
1218fp_e2i_small\b:
1219	fp_set_sr FPSR_EXC_INEX2
1220	clr.l	%d0
1221	move.w	(FPD_RND,FPDATA),%d2	| rounding mode
1222	subq.w	#2,%d2
1223	jcs	3f			| %d2 < 2, round to nearest/zero
1224	jhi	2f			| %d2 > 2, round to +infinity
1225	tst.w	(-4,%a0)		| to -inf
1226	jeq	3f
1227	subq.\s	#1,%d0
1228	jra	3f
12292:	tst.w	(-4,%a0)		| to +inf
1230	jne	3f
1231	addq.\s	#1,%d0
12323:	printf	PCONV,"-> %p\n",1,%d0
1233	rts
1234fp_e2i_large\b:
1235	fp_set_sr FPSR_EXC_OPERR
1236	move.\s	#inf,%d0
1237	tst.w	(-4,%a0)
1238	jeq	1f
1239	addq.\s	#1,%d0
12401:	printf	PCONV,"-> %p\n",1,%d0
1241	rts
1242fp_e2i_huge\b:
1243	move.\s	(%a0),%d0
1244	tst.l	(%a0)
1245	jne	1f
1246	tst.l	(%a0)
1247	jeq	fp_e2i_large\b
1248	| fp_normalize_ext has set this bit already
1249	| and made the number nonsignaling
12501:	fp_tst_sr FPSR_EXC_SNAN
1251	jne	1f
1252	fp_set_sr FPSR_EXC_OPERR
12531:	printf	PCONV,"-> %p\n",1,%d0
1254	rts
1255.endm
1256
1257fp_conv_ext2long:
1258	conv_ext2int l,32
1259
1260fp_conv_ext2short:
1261	conv_ext2int w,16
1262
1263fp_conv_ext2byte:
1264	conv_ext2int b,8
1265
1266fp_conv_ext2double:
1267	jsr	fp_normalize_double
1268	printf	PCONV,"e2d: %p(",1,%a0
1269	printx	PCONV,%a0@
1270	printf	PCONV,"), "
1271	move.l	(%a0)+,%d2
1272	cmp.w	#0x7fff,%d2
1273	jne	1f
1274	move.w	#0x7ff,%d2
1275	move.l	(%a0)+,%d0
1276	jra	2f
12771:	sub.w	#0x3fff-0x3ff,%d2
1278	move.l	(%a0)+,%d0
1279	jmi	2f
1280	clr.w	%d2
12812:	lsl.w	#5,%d2
1282	lsl.l	#7,%d2
1283	lsl.l	#8,%d2
1284	move.l	%d0,%d1
1285	lsl.l	#1,%d0
1286	lsr.l	#4,%d0
1287	lsr.l	#8,%d0
1288	or.l	%d2,%d0
1289	putuser.l %d0,(%a1)+,fp_err_ua2,%a1
1290	moveq	#21,%d0
1291	lsl.l	%d0,%d1
1292	move.l	(%a0),%d0
1293	lsr.l	#4,%d0
1294	lsr.l	#7,%d0
1295	or.l	%d1,%d0
1296	putuser.l %d0,(%a1),fp_err_ua2,%a1
1297#ifdef FPU_EMU_DEBUG
1298	getuser.l %a1@(-4),%d0,fp_err_ua2,%a1
1299	getuser.l %a1@(0),%d1,fp_err_ua2,%a1
1300	printf	PCONV,"%p(%08x%08x)\n",3,%a1,%d0,%d1
1301#endif
1302	rts
1303
1304fp_conv_ext2single:
1305	jsr	fp_normalize_single
1306	printf	PCONV,"e2s: %p(",1,%a0
1307	printx	PCONV,%a0@
1308	printf	PCONV,"), "
1309	move.l	(%a0)+,%d1
1310	cmp.w	#0x7fff,%d1
1311	jne	1f
1312	move.w	#0xff,%d1
1313	move.l	(%a0)+,%d0
1314	jra	2f
13151:	sub.w	#0x3fff-0x7f,%d1
1316	move.l	(%a0)+,%d0
1317	jmi	2f
1318	clr.w	%d1
13192:	lsl.w	#8,%d1
1320	lsl.l	#7,%d1
1321	lsl.l	#8,%d1
1322	bclr	#31,%d0
1323	lsr.l	#8,%d0
1324	or.l	%d1,%d0
1325	printf	PCONV,"%08x\n",1,%d0
1326	rts
1327
1328	| special return addresses for instr that
1329	| encode the rounding precision in the opcode
1330	| (e.g. fsmove,fdmove)
1331
1332fp_finalrounding_single:
1333	addq.l	#8,%sp
1334	jsr	fp_normalize_ext
1335	jsr	fp_normalize_single
1336	jra	fp_finaltest
1337
1338fp_finalrounding_single_fast:
1339	addq.l	#8,%sp
1340	jsr	fp_normalize_ext
1341	jsr	fp_normalize_single_fast
1342	jra	fp_finaltest
1343
1344fp_finalrounding_double:
1345	addq.l	#8,%sp
1346	jsr	fp_normalize_ext
1347	jsr	fp_normalize_double
1348	jra	fp_finaltest
1349
1350	| fp_finaltest:
1351	| set the emulated status register based on the outcome of an
1352	| emulated instruction.
1353
1354fp_finalrounding:
1355	addq.l	#8,%sp
1356|	printf	,"f: %p\n",1,%a0
1357	jsr	fp_normalize_ext
1358	move.w	(FPD_PREC,FPDATA),%d0
1359	subq.w	#1,%d0
1360	jcs	fp_finaltest
1361	jne	1f
1362	jsr	fp_normalize_single
1363	jra	2f
13641:	jsr	fp_normalize_double
13652:|	printf	,"f: %p\n",1,%a0
1366fp_finaltest:
1367	| First, we do some of the obvious tests for the exception
1368	| status byte and condition code bytes of fp_sr here, so that
1369	| they do not have to be handled individually by every
1370	| emulated instruction.
1371	clr.l	%d0
1372	addq.l	#1,%a0
1373	tst.b	(%a0)+			| sign
1374	jeq	1f
1375	bset	#FPSR_CC_NEG-24,%d0	| N bit
13761:	cmp.w	#0x7fff,(%a0)+		| exponent
1377	jeq	2f
1378	| test for zero
1379	moveq	#FPSR_CC_Z-24,%d1
1380	tst.l	(%a0)+
1381	jne	9f
1382	tst.l	(%a0)
1383	jne	9f
1384	jra	8f
1385	| infinitiv and NAN
13862:	moveq	#FPSR_CC_NAN-24,%d1
1387	move.l	(%a0)+,%d2
1388	lsl.l	#1,%d2			| ignore high bit
1389	jne	8f
1390	tst.l	(%a0)
1391	jne	8f
1392	moveq	#FPSR_CC_INF-24,%d1
13938:	bset	%d1,%d0
13949:	move.b	%d0,(FPD_FPSR+0,FPDATA)	| set condition test result
1395	| move instructions enter here
1396	| Here, we test things in the exception status byte, and set
1397	| other things in the accrued exception byte accordingly.
1398	| Emulated instructions can set various things in the former,
1399	| as defined in fp_emu.h.
1400fp_final:
1401	move.l	(FPD_FPSR,FPDATA),%d0
1402#if 0
1403	btst	#FPSR_EXC_SNAN,%d0	| EXC_SNAN
1404	jne	1f
1405	btst	#FPSR_EXC_OPERR,%d0	| EXC_OPERR
1406	jeq	2f
14071:	bset	#FPSR_AEXC_IOP,%d0	| set IOP bit
14082:	btst	#FPSR_EXC_OVFL,%d0	| EXC_OVFL
1409	jeq	1f
1410	bset	#FPSR_AEXC_OVFL,%d0	| set OVFL bit
14111:	btst	#FPSR_EXC_UNFL,%d0	| EXC_UNFL
1412	jeq	1f
1413	btst	#FPSR_EXC_INEX2,%d0	| EXC_INEX2
1414	jeq	1f
1415	bset	#FPSR_AEXC_UNFL,%d0	| set UNFL bit
14161:	btst	#FPSR_EXC_DZ,%d0	| EXC_INEX1
1417	jeq	1f
1418	bset	#FPSR_AEXC_DZ,%d0	| set DZ bit
14191:	btst	#FPSR_EXC_OVFL,%d0	| EXC_OVFL
1420	jne	1f
1421	btst	#FPSR_EXC_INEX2,%d0	| EXC_INEX2
1422	jne	1f
1423	btst	#FPSR_EXC_INEX1,%d0	| EXC_INEX1
1424	jeq	2f
14251:	bset	#FPSR_AEXC_INEX,%d0	| set INEX bit
14262:	move.l	%d0,(FPD_FPSR,FPDATA)
1427#else
1428	| same as above, greatly optimized, but untested (yet)
1429	move.l	%d0,%d2
1430	lsr.l	#5,%d0
1431	move.l	%d0,%d1
1432	lsr.l	#4,%d1
1433	or.l	%d0,%d1
1434	and.b	#0x08,%d1
1435	move.l	%d2,%d0
1436	lsr.l	#6,%d0
1437	or.l	%d1,%d0
1438	move.l	%d2,%d1
1439	lsr.l	#4,%d1
1440	or.b	#0xdf,%d1
1441	and.b	%d1,%d0
1442	move.l	%d2,%d1
1443	lsr.l	#7,%d1
1444	and.b	#0x80,%d1
1445	or.b	%d1,%d0
1446	and.b	#0xf8,%d0
1447	or.b	%d0,%d2
1448	move.l	%d2,(FPD_FPSR,FPDATA)
1449#endif
1450	move.b	(FPD_FPSR+2,FPDATA),%d0
1451	and.b	(FPD_FPCR+2,FPDATA),%d0
1452	jeq	1f
1453	printf	,"send signal!!!\n"
14541:	jra	fp_end
1455